mirror of https://github.com/ethereum/go-ethereum
cmd/geth: add --config file flag (#13875)
* p2p/discover, p2p/discv5: add marshaling methods to Node * p2p/netutil: make Netlist decodable from TOML * common/math: encode nil HexOrDecimal256 as 0x0 * cmd/geth: add --config file flag * cmd/geth: add missing license header * eth: prettify Config again, fix tests * eth: use gasprice.Config instead of duplicating its fields * eth/gasprice: hide nil default from dumpconfig output * cmd/geth: hide genesis block in dumpconfig output * node: make tests compile * console: fix tests * cmd/geth: make TOML keys look exactly like Go struct fields * p2p: use discovery by default This makes the zero Config slightly more useful. It also fixes package node tests because Node detects reuse of the datadir through the NodeDatabase. * cmd/geth: make ethstats URL settable through config file * cmd/faucet: fix configuration * cmd/geth: dedup attach tests * eth: add comment for DefaultConfig * eth: pass downloader.SyncMode in Config This removes the FastSync, LightSync flags in favour of a more general SyncMode flag. * cmd/utils: remove jitvm flags * cmd/utils: make mutually exclusive flag error prettier It now reads: Fatal: flags --dev, --testnet can't be used at the same time * p2p: fix typo * node: add DefaultConfig, use it for geth * mobile: add missing NoDiscovery option * cmd/utils: drop MakeNode This exposed a couple of places that needed to be updated to use node.DefaultConfig. * node: fix typo * eth: make fast sync the default mode * cmd/utils: remove IPCApiFlag (unused) * node: remove default IPC path Set it in the frontends instead. * cmd/geth: add --syncmode * cmd/utils: make --ipcdisable and --ipcpath mutually exclusive * cmd/utils: don't enable WS, HTTP when setting addr * cmd/utils: fix --identitypull/14323/head
Felix Lange
8 years ago
committed by
Péter Szilágyi
parent
b57680b0b2
commit
30d706c35e
@ -0,0 +1,186 @@ |
||||
// Copyright 2015 The go-ethereum Authors
|
||||
// This file is part of go-ethereum.
|
||||
//
|
||||
// go-ethereum is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// go-ethereum is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
package main |
||||
|
||||
import ( |
||||
"bufio" |
||||
"encoding/hex" |
||||
"errors" |
||||
"fmt" |
||||
"io" |
||||
"os" |
||||
"reflect" |
||||
"unicode" |
||||
|
||||
cli "gopkg.in/urfave/cli.v1" |
||||
|
||||
"github.com/ethereum/go-ethereum/cmd/utils" |
||||
"github.com/ethereum/go-ethereum/contracts/release" |
||||
"github.com/ethereum/go-ethereum/eth" |
||||
"github.com/ethereum/go-ethereum/node" |
||||
"github.com/ethereum/go-ethereum/params" |
||||
"github.com/naoina/toml" |
||||
) |
||||
|
||||
var ( |
||||
dumpConfigCommand = cli.Command{ |
||||
Action: dumpConfig, |
||||
Name: "dumpconfig", |
||||
Usage: "Show configuration values", |
||||
ArgsUsage: "", |
||||
Category: "MISCELLANEOUS COMMANDS", |
||||
Description: `The dumpconfig command shows configuration values.`, |
||||
} |
||||
|
||||
configFileFlag = cli.StringFlag{ |
||||
Name: "config", |
||||
Usage: "TOML configuration file", |
||||
} |
||||
) |
||||
|
||||
// These settings ensure that TOML keys use the same names as Go struct fields.
|
||||
var tomlSettings = toml.Config{ |
||||
NormFieldName: func(rt reflect.Type, key string) string { |
||||
return key |
||||
}, |
||||
FieldToKey: func(rt reflect.Type, field string) string { |
||||
return field |
||||
}, |
||||
MissingField: func(rt reflect.Type, field string) error { |
||||
link := "" |
||||
if unicode.IsUpper(rune(rt.Name()[0])) && rt.PkgPath() != "main" { |
||||
link = fmt.Sprintf(", see https://godoc.org/%s#%s for available fields", rt.PkgPath(), rt.Name()) |
||||
} |
||||
return fmt.Errorf("field '%s' is not defined in %s%s", field, rt.String(), link) |
||||
}, |
||||
} |
||||
|
||||
type ethstatsConfig struct { |
||||
URL string `toml:",omitempty"` |
||||
} |
||||
|
||||
type gethConfig struct { |
||||
Eth eth.Config |
||||
Node node.Config |
||||
Ethstats ethstatsConfig |
||||
} |
||||
|
||||
func loadConfig(file string, cfg *gethConfig) error { |
||||
f, err := os.Open(file) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
defer f.Close() |
||||
|
||||
err = tomlSettings.NewDecoder(bufio.NewReader(f)).Decode(cfg) |
||||
// Add file name to errors that have a line number.
|
||||
if _, ok := err.(*toml.LineError); ok { |
||||
err = errors.New(file + ", " + err.Error()) |
||||
} |
||||
return err |
||||
} |
||||
|
||||
func defaultNodeConfig() node.Config { |
||||
cfg := node.DefaultConfig |
||||
cfg.Name = clientIdentifier |
||||
cfg.Version = params.VersionWithCommit(gitCommit) |
||||
cfg.HTTPModules = append(cfg.HTTPModules, "eth") |
||||
cfg.WSModules = append(cfg.WSModules, "eth") |
||||
cfg.IPCPath = "geth.ipc" |
||||
return cfg |
||||
} |
||||
|
||||
func makeConfigNode(ctx *cli.Context) (*node.Node, gethConfig) { |
||||
// Load defaults.
|
||||
cfg := gethConfig{ |
||||
Eth: eth.DefaultConfig, |
||||
Node: defaultNodeConfig(), |
||||
} |
||||
|
||||
// Load config file.
|
||||
if file := ctx.GlobalString(configFileFlag.Name); file != "" { |
||||
if err := loadConfig(file, &cfg); err != nil { |
||||
utils.Fatalf("%v", err) |
||||
} |
||||
} |
||||
|
||||
// Apply flags.
|
||||
utils.SetNodeConfig(ctx, &cfg.Node) |
||||
stack, err := node.New(&cfg.Node) |
||||
if err != nil { |
||||
utils.Fatalf("Failed to create the protocol stack: %v", err) |
||||
} |
||||
utils.SetEthConfig(ctx, stack, &cfg.Eth) |
||||
if ctx.GlobalIsSet(utils.EthStatsURLFlag.Name) { |
||||
cfg.Ethstats.URL = ctx.GlobalString(utils.EthStatsURLFlag.Name) |
||||
} |
||||
|
||||
return stack, cfg |
||||
} |
||||
|
||||
func makeFullNode(ctx *cli.Context) *node.Node { |
||||
stack, cfg := makeConfigNode(ctx) |
||||
|
||||
utils.RegisterEthService(stack, &cfg.Eth) |
||||
|
||||
// Whisper must be explicitly enabled, but is auto-enabled in --dev mode.
|
||||
shhEnabled := ctx.GlobalBool(utils.WhisperEnabledFlag.Name) |
||||
shhAutoEnabled := !ctx.GlobalIsSet(utils.WhisperEnabledFlag.Name) && ctx.GlobalIsSet(utils.DevModeFlag.Name) |
||||
if shhEnabled || shhAutoEnabled { |
||||
utils.RegisterShhService(stack) |
||||
} |
||||
|
||||
// Add the Ethereum Stats daemon if requested.
|
||||
if cfg.Ethstats.URL != "" { |
||||
utils.RegisterEthStatsService(stack, cfg.Ethstats.URL) |
||||
} |
||||
|
||||
// Add the release oracle service so it boots along with node.
|
||||
if err := stack.Register(func(ctx *node.ServiceContext) (node.Service, error) { |
||||
config := release.Config{ |
||||
Oracle: relOracle, |
||||
Major: uint32(params.VersionMajor), |
||||
Minor: uint32(params.VersionMinor), |
||||
Patch: uint32(params.VersionPatch), |
||||
} |
||||
commit, _ := hex.DecodeString(gitCommit) |
||||
copy(config.Commit[:], commit) |
||||
return release.NewReleaseService(ctx, config) |
||||
}); err != nil { |
||||
utils.Fatalf("Failed to register the Geth release oracle service: %v", err) |
||||
} |
||||
return stack |
||||
} |
||||
|
||||
// dumpConfig is the dumpconfig command.
|
||||
func dumpConfig(ctx *cli.Context) error { |
||||
_, cfg := makeConfigNode(ctx) |
||||
comment := "" |
||||
|
||||
if cfg.Eth.Genesis != nil { |
||||
cfg.Eth.Genesis = nil |
||||
comment += "# Note: this config doesn't contain the genesis block.\n\n" |
||||
} |
||||
|
||||
out, err := tomlSettings.Marshal(&cfg) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
io.WriteString(os.Stdout, comment) |
||||
os.Stdout.Write(out) |
||||
return nil |
||||
} |
||||
@ -0,0 +1,117 @@ |
||||
// Copyright 2014 The go-ethereum Authors
|
||||
// This file is part of the go-ethereum library.
|
||||
//
|
||||
// The go-ethereum library is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Lesser General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// The go-ethereum library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU Lesser General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Lesser General Public License
|
||||
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
package eth |
||||
|
||||
import ( |
||||
"math/big" |
||||
"os" |
||||
"os/user" |
||||
"path/filepath" |
||||
"runtime" |
||||
|
||||
"github.com/ethereum/go-ethereum/common" |
||||
"github.com/ethereum/go-ethereum/common/hexutil" |
||||
"github.com/ethereum/go-ethereum/core" |
||||
"github.com/ethereum/go-ethereum/eth/downloader" |
||||
"github.com/ethereum/go-ethereum/eth/gasprice" |
||||
"github.com/ethereum/go-ethereum/params" |
||||
) |
||||
|
||||
// DefaultConfig contains default settings for use on the Ethereum main net.
|
||||
var DefaultConfig = Config{ |
||||
SyncMode: downloader.FastSync, |
||||
EthashCachesInMem: 2, |
||||
EthashCachesOnDisk: 3, |
||||
EthashDatasetsInMem: 1, |
||||
EthashDatasetsOnDisk: 2, |
||||
NetworkId: 1, |
||||
LightPeers: 20, |
||||
DatabaseCache: 128, |
||||
GasPrice: big.NewInt(20 * params.Shannon), |
||||
|
||||
GPO: gasprice.Config{ |
||||
Blocks: 10, |
||||
Percentile: 50, |
||||
}, |
||||
} |
||||
|
||||
func init() { |
||||
home := os.Getenv("HOME") |
||||
if home == "" { |
||||
if user, err := user.Current(); err == nil { |
||||
home = user.HomeDir |
||||
} |
||||
} |
||||
if runtime.GOOS == "windows" { |
||||
DefaultConfig.EthashDatasetDir = filepath.Join(home, "AppData", "Ethash") |
||||
} else { |
||||
DefaultConfig.EthashDatasetDir = filepath.Join(home, ".ethash") |
||||
} |
||||
} |
||||
|
||||
//go:generate gencodec -type Config -field-override configMarshaling -formats toml -out gen_config.go
|
||||
|
||||
type Config struct { |
||||
// The genesis block, which is inserted if the database is empty.
|
||||
// If nil, the Ethereum main net block is used.
|
||||
Genesis *core.Genesis `toml:",omitempty"` |
||||
|
||||
// Protocol options
|
||||
NetworkId int // Network ID to use for selecting peers to connect to
|
||||
SyncMode downloader.SyncMode |
||||
|
||||
// Light client options
|
||||
LightServ int `toml:",omitempty"` // Maximum percentage of time allowed for serving LES requests
|
||||
LightPeers int `toml:",omitempty"` // Maximum number of LES client peers
|
||||
MaxPeers int `toml:"-"` // Maximum number of global peers
|
||||
|
||||
// Database options
|
||||
SkipBcVersionCheck bool `toml:"-"` |
||||
DatabaseHandles int `toml:"-"` |
||||
DatabaseCache int |
||||
|
||||
// Mining-related options
|
||||
Etherbase common.Address `toml:",omitempty"` |
||||
MinerThreads int `toml:",omitempty"` |
||||
ExtraData []byte `toml:",omitempty"` |
||||
GasPrice *big.Int |
||||
|
||||
// Ethash options
|
||||
EthashCacheDir string |
||||
EthashCachesInMem int |
||||
EthashCachesOnDisk int |
||||
EthashDatasetDir string |
||||
EthashDatasetsInMem int |
||||
EthashDatasetsOnDisk int |
||||
|
||||
// Gas Price Oracle options
|
||||
GPO gasprice.Config |
||||
|
||||
// Enables tracking of SHA3 preimages in the VM
|
||||
EnablePreimageRecording bool |
||||
|
||||
// Miscellaneous options
|
||||
SolcPath string |
||||
DocRoot string `toml:"-"` |
||||
PowFake bool `toml:"-"` |
||||
PowTest bool `toml:"-"` |
||||
PowShared bool `toml:"-"` |
||||
} |
||||
|
||||
type configMarshaling struct { |
||||
ExtraData hexutil.Bytes |
||||
} |
||||
@ -0,0 +1,186 @@ |
||||
// Code generated by github.com/fjl/gencodec. DO NOT EDIT.
|
||||
|
||||
package eth |
||||
|
||||
import ( |
||||
"math/big" |
||||
|
||||
"github.com/ethereum/go-ethereum/common" |
||||
"github.com/ethereum/go-ethereum/common/hexutil" |
||||
"github.com/ethereum/go-ethereum/core" |
||||
"github.com/ethereum/go-ethereum/eth/downloader" |
||||
"github.com/ethereum/go-ethereum/eth/gasprice" |
||||
) |
||||
|
||||
func (c Config) MarshalTOML() (interface{}, error) { |
||||
type Config struct { |
||||
Genesis *core.Genesis `toml:",omitempty"` |
||||
NetworkId int |
||||
SyncMode downloader.SyncMode |
||||
LightServ int `toml:",omitempty"` |
||||
LightPeers int `toml:",omitempty"` |
||||
MaxPeers int `toml:"-"` |
||||
SkipBcVersionCheck bool `toml:"-"` |
||||
DatabaseHandles int `toml:"-"` |
||||
DatabaseCache int |
||||
Etherbase common.Address `toml:",omitempty"` |
||||
MinerThreads int `toml:",omitempty"` |
||||
ExtraData hexutil.Bytes `toml:",omitempty"` |
||||
GasPrice *big.Int |
||||
EthashCacheDir string |
||||
EthashCachesInMem int |
||||
EthashCachesOnDisk int |
||||
EthashDatasetDir string |
||||
EthashDatasetsInMem int |
||||
EthashDatasetsOnDisk int |
||||
GPO gasprice.Config |
||||
EnablePreimageRecording bool |
||||
SolcPath string |
||||
DocRoot string `toml:"-"` |
||||
PowFake bool `toml:"-"` |
||||
PowTest bool `toml:"-"` |
||||
PowShared bool `toml:"-"` |
||||
} |
||||
var enc Config |
||||
enc.Genesis = c.Genesis |
||||
enc.NetworkId = c.NetworkId |
||||
enc.SyncMode = c.SyncMode |
||||
enc.LightServ = c.LightServ |
||||
enc.LightPeers = c.LightPeers |
||||
enc.MaxPeers = c.MaxPeers |
||||
enc.SkipBcVersionCheck = c.SkipBcVersionCheck |
||||
enc.DatabaseHandles = c.DatabaseHandles |
||||
enc.DatabaseCache = c.DatabaseCache |
||||
enc.Etherbase = c.Etherbase |
||||
enc.MinerThreads = c.MinerThreads |
||||
enc.ExtraData = c.ExtraData |
||||
enc.GasPrice = c.GasPrice |
||||
enc.EthashCacheDir = c.EthashCacheDir |
||||
enc.EthashCachesInMem = c.EthashCachesInMem |
||||
enc.EthashCachesOnDisk = c.EthashCachesOnDisk |
||||
enc.EthashDatasetDir = c.EthashDatasetDir |
||||
enc.EthashDatasetsInMem = c.EthashDatasetsInMem |
||||
enc.EthashDatasetsOnDisk = c.EthashDatasetsOnDisk |
||||
enc.GPO = c.GPO |
||||
enc.EnablePreimageRecording = c.EnablePreimageRecording |
||||
enc.SolcPath = c.SolcPath |
||||
enc.DocRoot = c.DocRoot |
||||
enc.PowFake = c.PowFake |
||||
enc.PowTest = c.PowTest |
||||
enc.PowShared = c.PowShared |
||||
return &enc, nil |
||||
} |
||||
|
||||
func (c *Config) UnmarshalTOML(unmarshal func(interface{}) error) error { |
||||
type Config struct { |
||||
Genesis *core.Genesis `toml:",omitempty"` |
||||
NetworkId *int |
||||
SyncMode *downloader.SyncMode |
||||
LightServ *int `toml:",omitempty"` |
||||
LightPeers *int `toml:",omitempty"` |
||||
MaxPeers *int `toml:"-"` |
||||
SkipBcVersionCheck *bool `toml:"-"` |
||||
DatabaseHandles *int `toml:"-"` |
||||
DatabaseCache *int |
||||
Etherbase *common.Address `toml:",omitempty"` |
||||
MinerThreads *int `toml:",omitempty"` |
||||
ExtraData hexutil.Bytes `toml:",omitempty"` |
||||
GasPrice *big.Int |
||||
EthashCacheDir *string |
||||
EthashCachesInMem *int |
||||
EthashCachesOnDisk *int |
||||
EthashDatasetDir *string |
||||
EthashDatasetsInMem *int |
||||
EthashDatasetsOnDisk *int |
||||
GPO *gasprice.Config |
||||
EnablePreimageRecording *bool |
||||
SolcPath *string |
||||
DocRoot *string `toml:"-"` |
||||
PowFake *bool `toml:"-"` |
||||
PowTest *bool `toml:"-"` |
||||
PowShared *bool `toml:"-"` |
||||
} |
||||
var dec Config |
||||
if err := unmarshal(&dec); err != nil { |
||||
return err |
||||
} |
||||
if dec.Genesis != nil { |
||||
c.Genesis = dec.Genesis |
||||
} |
||||
if dec.NetworkId != nil { |
||||
c.NetworkId = *dec.NetworkId |
||||
} |
||||
if dec.SyncMode != nil { |
||||
c.SyncMode = *dec.SyncMode |
||||
} |
||||
if dec.LightServ != nil { |
||||
c.LightServ = *dec.LightServ |
||||
} |
||||
if dec.LightPeers != nil { |
||||
c.LightPeers = *dec.LightPeers |
||||
} |
||||
if dec.MaxPeers != nil { |
||||
c.MaxPeers = *dec.MaxPeers |
||||
} |
||||
if dec.SkipBcVersionCheck != nil { |
||||
c.SkipBcVersionCheck = *dec.SkipBcVersionCheck |
||||
} |
||||
if dec.DatabaseHandles != nil { |
||||
c.DatabaseHandles = *dec.DatabaseHandles |
||||
} |
||||
if dec.DatabaseCache != nil { |
||||
c.DatabaseCache = *dec.DatabaseCache |
||||
} |
||||
if dec.Etherbase != nil { |
||||
c.Etherbase = *dec.Etherbase |
||||
} |
||||
if dec.MinerThreads != nil { |
||||
c.MinerThreads = *dec.MinerThreads |
||||
} |
||||
if dec.ExtraData != nil { |
||||
c.ExtraData = dec.ExtraData |
||||
} |
||||
if dec.GasPrice != nil { |
||||
c.GasPrice = dec.GasPrice |
||||
} |
||||
if dec.EthashCacheDir != nil { |
||||
c.EthashCacheDir = *dec.EthashCacheDir |
||||
} |
||||
if dec.EthashCachesInMem != nil { |
||||
c.EthashCachesInMem = *dec.EthashCachesInMem |
||||
} |
||||
if dec.EthashCachesOnDisk != nil { |
||||
c.EthashCachesOnDisk = *dec.EthashCachesOnDisk |
||||
} |
||||
if dec.EthashDatasetDir != nil { |
||||
c.EthashDatasetDir = *dec.EthashDatasetDir |
||||
} |
||||
if dec.EthashDatasetsInMem != nil { |
||||
c.EthashDatasetsInMem = *dec.EthashDatasetsInMem |
||||
} |
||||
if dec.EthashDatasetsOnDisk != nil { |
||||
c.EthashDatasetsOnDisk = *dec.EthashDatasetsOnDisk |
||||
} |
||||
if dec.GPO != nil { |
||||
c.GPO = *dec.GPO |
||||
} |
||||
if dec.EnablePreimageRecording != nil { |
||||
c.EnablePreimageRecording = *dec.EnablePreimageRecording |
||||
} |
||||
if dec.SolcPath != nil { |
||||
c.SolcPath = *dec.SolcPath |
||||
} |
||||
if dec.DocRoot != nil { |
||||
c.DocRoot = *dec.DocRoot |
||||
} |
||||
if dec.PowFake != nil { |
||||
c.PowFake = *dec.PowFake |
||||
} |
||||
if dec.PowTest != nil { |
||||
c.PowTest = *dec.PowTest |
||||
} |
||||
if dec.PowShared != nil { |
||||
c.PowShared = *dec.PowShared |
||||
} |
||||
return nil |
||||
} |
||||
@ -0,0 +1,19 @@ |
||||
Copyright (c) 2015 Naoya Inada <naoina@kuune.org> |
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy |
||||
of this software and associated documentation files (the "Software"), to deal |
||||
in the Software without restriction, including without limitation the rights |
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
||||
copies of the Software, and to permit persons to whom the Software is |
||||
furnished to do so, subject to the following conditions: |
||||
|
||||
The above copyright notice and this permission notice shall be included in |
||||
all copies or substantial portions of the Software. |
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
||||
THE SOFTWARE. |
||||
@ -0,0 +1,13 @@ |
||||
# stringutil [](https://travis-ci.org/naoina/go-stringutil) |
||||
|
||||
## Installation |
||||
|
||||
go get -u github.com/naoina/go-stringutil |
||||
|
||||
## Documentation |
||||
|
||||
See https://godoc.org/github.com/naoina/go-stringutil |
||||
|
||||
## License |
||||
|
||||
MIT |
||||
@ -0,0 +1,253 @@ |
||||
package stringutil |
||||
|
||||
import ( |
||||
"fmt" |
||||
"sort" |
||||
"unicode/utf8" |
||||
) |
||||
|
||||
const ( |
||||
terminationCharacter = '#' |
||||
) |
||||
|
||||
func mustDoubleArray(da *doubleArray, err error) *doubleArray { |
||||
if err != nil { |
||||
panic(err) |
||||
} |
||||
return da |
||||
} |
||||
|
||||
func (da *doubleArray) Build(keys []string) error { |
||||
records := makeRecords(keys) |
||||
if err := da.build(records, 1, 0, make(map[int]struct{})); err != nil { |
||||
return err |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
type doubleArray struct { |
||||
bc []baseCheck |
||||
node []int |
||||
} |
||||
|
||||
func newDoubleArray(keys []string) (*doubleArray, error) { |
||||
da := &doubleArray{ |
||||
bc: []baseCheck{0}, |
||||
node: []int{-1}, // A start index is adjusting to 1 because 0 will be used as a mark of non-existent node.
|
||||
} |
||||
if err := da.Build(keys); err != nil { |
||||
return nil, err |
||||
} |
||||
return da, nil |
||||
} |
||||
|
||||
// baseCheck contains BASE, CHECK and Extra flags.
|
||||
// From the top, 22bits of BASE, 2bits of Extra flags and 8bits of CHECK.
|
||||
//
|
||||
// BASE (22bit) | Extra flags (2bit) | CHECK (8bit)
|
||||
// |----------------------|--|--------|
|
||||
// 32 10 8 0
|
||||
type baseCheck uint32 |
||||
|
||||
func (bc baseCheck) Base() int { |
||||
return int(bc >> 10) |
||||
} |
||||
|
||||
func (bc *baseCheck) SetBase(base int) { |
||||
*bc |= baseCheck(base) << 10 |
||||
} |
||||
|
||||
func (bc baseCheck) Check() byte { |
||||
return byte(bc) |
||||
} |
||||
|
||||
func (bc *baseCheck) SetCheck(check byte) { |
||||
*bc |= baseCheck(check) |
||||
} |
||||
|
||||
func (bc baseCheck) IsEmpty() bool { |
||||
return bc&0xfffffcff == 0 |
||||
} |
||||
|
||||
func (da *doubleArray) Lookup(path string) (length int) { |
||||
idx := 1 |
||||
tmpIdx := idx |
||||
for i := 0; i < len(path); i++ { |
||||
c := path[i] |
||||
tmpIdx = da.nextIndex(da.bc[tmpIdx].Base(), c) |
||||
if tmpIdx >= len(da.bc) || da.bc[tmpIdx].Check() != c { |
||||
break |
||||
} |
||||
idx = tmpIdx |
||||
} |
||||
if next := da.nextIndex(da.bc[idx].Base(), terminationCharacter); next < len(da.bc) && da.bc[next].Check() == terminationCharacter { |
||||
return da.node[da.bc[next].Base()] |
||||
} |
||||
return -1 |
||||
} |
||||
|
||||
func (da *doubleArray) LookupByBytes(path []byte) (length int) { |
||||
idx := 1 |
||||
tmpIdx := idx |
||||
for i := 0; i < len(path); i++ { |
||||
c := path[i] |
||||
tmpIdx = da.nextIndex(da.bc[tmpIdx].Base(), c) |
||||
if tmpIdx >= len(da.bc) || da.bc[tmpIdx].Check() != c { |
||||
break |
||||
} |
||||
idx = tmpIdx |
||||
} |
||||
if next := da.nextIndex(da.bc[idx].Base(), terminationCharacter); next < len(da.bc) && da.bc[next].Check() == terminationCharacter { |
||||
return da.node[da.bc[next].Base()] |
||||
} |
||||
return -1 |
||||
} |
||||
|
||||
func (da *doubleArray) build(srcs []record, idx, depth int, usedBase map[int]struct{}) error { |
||||
sort.Stable(recordSlice(srcs)) |
||||
base, siblings, leaf, err := da.arrange(srcs, idx, depth, usedBase) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
if leaf != nil { |
||||
da.bc[idx].SetBase(len(da.node)) |
||||
da.node = append(da.node, leaf.value) |
||||
} |
||||
for _, sib := range siblings { |
||||
da.setCheck(da.nextIndex(base, sib.c), sib.c) |
||||
} |
||||
for _, sib := range siblings { |
||||
if err := da.build(srcs[sib.start:sib.end], da.nextIndex(base, sib.c), depth+1, usedBase); err != nil { |
||||
return err |
||||
} |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
func (da *doubleArray) setBase(i, base int) { |
||||
da.bc[i].SetBase(base) |
||||
} |
||||
|
||||
func (da *doubleArray) setCheck(i int, check byte) { |
||||
da.bc[i].SetCheck(check) |
||||
} |
||||
|
||||
func (da *doubleArray) findEmptyIndex(start int) int { |
||||
i := start |
||||
for ; i < len(da.bc); i++ { |
||||
if da.bc[i].IsEmpty() { |
||||
break |
||||
} |
||||
} |
||||
return i |
||||
} |
||||
|
||||
// findBase returns good BASE.
|
||||
func (da *doubleArray) findBase(siblings []sibling, start int, usedBase map[int]struct{}) (base int) { |
||||
for idx, firstChar := start+1, siblings[0].c; ; idx = da.findEmptyIndex(idx + 1) { |
||||
base = da.nextIndex(idx, firstChar) |
||||
if _, used := usedBase[base]; used { |
||||
continue |
||||
} |
||||
i := 0 |
||||
for ; i < len(siblings); i++ { |
||||
next := da.nextIndex(base, siblings[i].c) |
||||
if len(da.bc) <= next { |
||||
da.bc = append(da.bc, make([]baseCheck, next-len(da.bc)+1)...) |
||||
} |
||||
if !da.bc[next].IsEmpty() { |
||||
break |
||||
} |
||||
} |
||||
if i == len(siblings) { |
||||
break |
||||
} |
||||
} |
||||
usedBase[base] = struct{}{} |
||||
return base |
||||
} |
||||
|
||||
func (da *doubleArray) arrange(records []record, idx, depth int, usedBase map[int]struct{}) (base int, siblings []sibling, leaf *record, err error) { |
||||
siblings, leaf, err = makeSiblings(records, depth) |
||||
if err != nil { |
||||
return -1, nil, nil, err |
||||
} |
||||
if len(siblings) < 1 { |
||||
return -1, nil, leaf, nil |
||||
} |
||||
base = da.findBase(siblings, idx, usedBase) |
||||
da.setBase(idx, base) |
||||
return base, siblings, leaf, err |
||||
} |
||||
|
||||
type sibling struct { |
||||
start int |
||||
end int |
||||
c byte |
||||
} |
||||
|
||||
func (da *doubleArray) nextIndex(base int, c byte) int { |
||||
return base ^ int(c) |
||||
} |
||||
|
||||
func makeSiblings(records []record, depth int) (sib []sibling, leaf *record, err error) { |
||||
var ( |
||||
pc byte |
||||
n int |
||||
) |
||||
for i, r := range records { |
||||
if len(r.key) <= depth { |
||||
leaf = &r |
||||
continue |
||||
} |
||||
c := r.key[depth] |
||||
switch { |
||||
case pc < c: |
||||
sib = append(sib, sibling{start: i, c: c}) |
||||
case pc == c: |
||||
continue |
||||
default: |
||||
return nil, nil, fmt.Errorf("stringutil: BUG: records hasn't been sorted") |
||||
} |
||||
if n > 0 { |
||||
sib[n-1].end = i |
||||
} |
||||
pc = c |
||||
n++ |
||||
} |
||||
if n == 0 { |
||||
return nil, leaf, nil |
||||
} |
||||
sib[n-1].end = len(records) |
||||
return sib, leaf, nil |
||||
} |
||||
|
||||
type record struct { |
||||
key string |
||||
value int |
||||
} |
||||
|
||||
func makeRecords(srcs []string) (records []record) { |
||||
termChar := string(terminationCharacter) |
||||
for _, s := range srcs { |
||||
records = append(records, record{ |
||||
key: string(s + termChar), |
||||
value: utf8.RuneCountInString(s), |
||||
}) |
||||
} |
||||
return records |
||||
} |
||||
|
||||
type recordSlice []record |
||||
|
||||
func (rs recordSlice) Len() int { |
||||
return len(rs) |
||||
} |
||||
|
||||
func (rs recordSlice) Less(i, j int) bool { |
||||
return rs[i].key < rs[j].key |
||||
} |
||||
|
||||
func (rs recordSlice) Swap(i, j int) { |
||||
rs[i], rs[j] = rs[j], rs[i] |
||||
} |
||||
@ -0,0 +1,320 @@ |
||||
package stringutil |
||||
|
||||
import ( |
||||
"sync" |
||||
"unicode" |
||||
"unicode/utf8" |
||||
) |
||||
|
||||
var ( |
||||
mu sync.Mutex |
||||
|
||||
// Based on https://github.com/golang/lint/blob/32a87160691b3c96046c0c678fe57c5bef761456/lint.go#L702
|
||||
commonInitialismMap = map[string]struct{}{ |
||||
"API": struct{}{}, |
||||
"ASCII": struct{}{}, |
||||
"CPU": struct{}{}, |
||||
"CSRF": struct{}{}, |
||||
"CSS": struct{}{}, |
||||
"DNS": struct{}{}, |
||||
"EOF": struct{}{}, |
||||
"GUID": struct{}{}, |
||||
"HTML": struct{}{}, |
||||
"HTTP": struct{}{}, |
||||
"HTTPS": struct{}{}, |
||||
"ID": struct{}{}, |
||||
"IP": struct{}{}, |
||||
"JSON": struct{}{}, |
||||
"LHS": struct{}{}, |
||||
"QPS": struct{}{}, |
||||
"RAM": struct{}{}, |
||||
"RHS": struct{}{}, |
||||
"RPC": struct{}{}, |
||||
"SLA": struct{}{}, |
||||
"SMTP": struct{}{}, |
||||
"SQL": struct{}{}, |
||||
"SSH": struct{}{}, |
||||
"TCP": struct{}{}, |
||||
"TLS": struct{}{}, |
||||
"TTL": struct{}{}, |
||||
"UDP": struct{}{}, |
||||
"UI": struct{}{}, |
||||
"UID": struct{}{}, |
||||
"UUID": struct{}{}, |
||||
"URI": struct{}{}, |
||||
"URL": struct{}{}, |
||||
"UTF8": struct{}{}, |
||||
"VM": struct{}{}, |
||||
"XML": struct{}{}, |
||||
"XSRF": struct{}{}, |
||||
"XSS": struct{}{}, |
||||
} |
||||
commonInitialisms = keys(commonInitialismMap) |
||||
commonInitialism = mustDoubleArray(newDoubleArray(commonInitialisms)) |
||||
longestLen = longestLength(commonInitialisms) |
||||
shortestLen = shortestLength(commonInitialisms, longestLen) |
||||
) |
||||
|
||||
// ToUpperCamelCase returns a copy of the string s with all Unicode letters mapped to their camel case.
|
||||
// It will convert to upper case previous letter of '_' and first letter, and remove letter of '_'.
|
||||
func ToUpperCamelCase(s string) string { |
||||
if s == "" { |
||||
return "" |
||||
} |
||||
upper := true |
||||
start := 0 |
||||
result := make([]byte, 0, len(s)) |
||||
var runeBuf [utf8.UTFMax]byte |
||||
var initialism []byte |
||||
for _, c := range s { |
||||
if c == '_' { |
||||
upper = true |
||||
candidate := string(result[start:]) |
||||
initialism = initialism[:0] |
||||
for _, r := range candidate { |
||||
if r < utf8.RuneSelf { |
||||
initialism = append(initialism, toUpperASCII(byte(r))) |
||||
} else { |
||||
n := utf8.EncodeRune(runeBuf[:], unicode.ToUpper(r)) |
||||
initialism = append(initialism, runeBuf[:n]...) |
||||
} |
||||
} |
||||
if length := commonInitialism.LookupByBytes(initialism); length > 0 { |
||||
result = append(result[:start], initialism...) |
||||
} |
||||
start = len(result) |
||||
continue |
||||
} |
||||
if upper { |
||||
if c < utf8.RuneSelf { |
||||
result = append(result, toUpperASCII(byte(c))) |
||||
} else { |
||||
n := utf8.EncodeRune(runeBuf[:], unicode.ToUpper(c)) |
||||
result = append(result, runeBuf[:n]...) |
||||
} |
||||
upper = false |
||||
continue |
||||
} |
||||
if c < utf8.RuneSelf { |
||||
result = append(result, byte(c)) |
||||
} else { |
||||
n := utf8.EncodeRune(runeBuf[:], c) |
||||
result = append(result, runeBuf[:n]...) |
||||
} |
||||
} |
||||
candidate := string(result[start:]) |
||||
initialism = initialism[:0] |
||||
for _, r := range candidate { |
||||
if r < utf8.RuneSelf { |
||||
initialism = append(initialism, toUpperASCII(byte(r))) |
||||
} else { |
||||
n := utf8.EncodeRune(runeBuf[:], unicode.ToUpper(r)) |
||||
initialism = append(initialism, runeBuf[:n]...) |
||||
} |
||||
} |
||||
if length := commonInitialism.LookupByBytes(initialism); length > 0 { |
||||
result = append(result[:start], initialism...) |
||||
} |
||||
return string(result) |
||||
} |
||||
|
||||
// ToUpperCamelCaseASCII is similar to ToUpperCamelCase, but optimized for
|
||||
// only the ASCII characters.
|
||||
// ToUpperCamelCaseASCII is faster than ToUpperCamelCase, but doesn't work if
|
||||
// contains non-ASCII characters.
|
||||
func ToUpperCamelCaseASCII(s string) string { |
||||
if s == "" { |
||||
return "" |
||||
} |
||||
upper := true |
||||
start := 0 |
||||
result := make([]byte, 0, len(s)) |
||||
var initialism []byte |
||||
for i := 0; i < len(s); i++ { |
||||
c := s[i] |
||||
if c == '_' { |
||||
upper = true |
||||
candidate := result[start:] |
||||
initialism = initialism[:0] |
||||
for _, b := range candidate { |
||||
initialism = append(initialism, toUpperASCII(b)) |
||||
} |
||||
if length := commonInitialism.LookupByBytes(initialism); length > 0 { |
||||
result = append(result[:start], initialism...) |
||||
} |
||||
start = len(result) |
||||
continue |
||||
} |
||||
if upper { |
||||
result = append(result, toUpperASCII(c)) |
||||
upper = false |
||||
continue |
||||
} |
||||
result = append(result, c) |
||||
} |
||||
candidate := result[start:] |
||||
initialism = initialism[:0] |
||||
for _, b := range candidate { |
||||
initialism = append(initialism, toUpperASCII(b)) |
||||
} |
||||
if length := commonInitialism.LookupByBytes(initialism); length > 0 { |
||||
result = append(result[:start], initialism...) |
||||
} |
||||
return string(result) |
||||
} |
||||
|
||||
// ToSnakeCase returns a copy of the string s with all Unicode letters mapped to their snake case.
|
||||
// It will insert letter of '_' at position of previous letter of uppercase and all
|
||||
// letters convert to lower case.
|
||||
// ToSnakeCase does not insert '_' letter into a common initialism word like ID, URL and so on.
|
||||
func ToSnakeCase(s string) string { |
||||
if s == "" { |
||||
return "" |
||||
} |
||||
result := make([]byte, 0, len(s)) |
||||
var runeBuf [utf8.UTFMax]byte |
||||
var j, skipCount int |
||||
for i, c := range s { |
||||
if i < skipCount { |
||||
continue |
||||
} |
||||
if unicode.IsUpper(c) { |
||||
if i != 0 { |
||||
result = append(result, '_') |
||||
} |
||||
next := nextIndex(j, len(s)) |
||||
if length := commonInitialism.Lookup(s[j:next]); length > 0 { |
||||
for _, r := range s[j : j+length] { |
||||
if r < utf8.RuneSelf { |
||||
result = append(result, toLowerASCII(byte(r))) |
||||
} else { |
||||
n := utf8.EncodeRune(runeBuf[:], unicode.ToLower(r)) |
||||
result = append(result, runeBuf[:n]...) |
||||
} |
||||
} |
||||
j += length - 1 |
||||
skipCount = i + length |
||||
continue |
||||
} |
||||
} |
||||
if c < utf8.RuneSelf { |
||||
result = append(result, toLowerASCII(byte(c))) |
||||
} else { |
||||
n := utf8.EncodeRune(runeBuf[:], unicode.ToLower(c)) |
||||
result = append(result, runeBuf[:n]...) |
||||
} |
||||
j++ |
||||
} |
||||
return string(result) |
||||
} |
||||
|
||||
// ToSnakeCaseASCII is similar to ToSnakeCase, but optimized for only the ASCII
|
||||
// characters.
|
||||
// ToSnakeCaseASCII is faster than ToSnakeCase, but doesn't work correctly if
|
||||
// contains non-ASCII characters.
|
||||
func ToSnakeCaseASCII(s string) string { |
||||
if s == "" { |
||||
return "" |
||||
} |
||||
result := make([]byte, 0, len(s)) |
||||
for i := 0; i < len(s); i++ { |
||||
c := s[i] |
||||
if isUpperASCII(c) { |
||||
if i != 0 { |
||||
result = append(result, '_') |
||||
} |
||||
if k := i + shortestLen - 1; k < len(s) && isUpperASCII(s[k]) { |
||||
if length := commonInitialism.Lookup(s[i:nextIndex(i, len(s))]); length > 0 { |
||||
for j, buf := 0, s[i:i+length]; j < len(buf); j++ { |
||||
result = append(result, toLowerASCII(buf[j])) |
||||
} |
||||
i += length - 1 |
||||
continue |
||||
} |
||||
} |
||||
} |
||||
result = append(result, toLowerASCII(c)) |
||||
} |
||||
return string(result) |
||||
} |
||||
|
||||
// AddCommonInitialism adds ss to list of common initialisms.
|
||||
func AddCommonInitialism(ss ...string) { |
||||
mu.Lock() |
||||
defer mu.Unlock() |
||||
for _, s := range ss { |
||||
commonInitialismMap[s] = struct{}{} |
||||
} |
||||
commonInitialisms = keys(commonInitialismMap) |
||||
commonInitialism = mustDoubleArray(newDoubleArray(commonInitialisms)) |
||||
longestLen = longestLength(commonInitialisms) |
||||
shortestLen = shortestLength(commonInitialisms, longestLen) |
||||
} |
||||
|
||||
// DelCommonInitialism deletes ss from list of common initialisms.
|
||||
func DelCommonInitialism(ss ...string) { |
||||
mu.Lock() |
||||
defer mu.Unlock() |
||||
for _, s := range ss { |
||||
delete(commonInitialismMap, s) |
||||
} |
||||
commonInitialisms = keys(commonInitialismMap) |
||||
commonInitialism = mustDoubleArray(newDoubleArray(commonInitialisms)) |
||||
longestLen = longestLength(commonInitialisms) |
||||
shortestLen = shortestLength(commonInitialisms, longestLen) |
||||
} |
||||
|
||||
func isUpperASCII(c byte) bool { |
||||
return 'A' <= c && c <= 'Z' |
||||
} |
||||
|
||||
func isLowerASCII(c byte) bool { |
||||
return 'a' <= c && c <= 'z' |
||||
} |
||||
|
||||
func toUpperASCII(c byte) byte { |
||||
if isLowerASCII(c) { |
||||
return c - ('a' - 'A') |
||||
} |
||||
return c |
||||
} |
||||
|
||||
func toLowerASCII(c byte) byte { |
||||
if isUpperASCII(c) { |
||||
return c + 'a' - 'A' |
||||
} |
||||
return c |
||||
} |
||||
|
||||
func nextIndex(i, maxlen int) int { |
||||
if n := i + longestLen; n < maxlen { |
||||
return n |
||||
} |
||||
return maxlen |
||||
} |
||||
|
||||
func keys(m map[string]struct{}) []string { |
||||
result := make([]string, 0, len(m)) |
||||
for k := range m { |
||||
result = append(result, k) |
||||
} |
||||
return result |
||||
} |
||||
|
||||
func shortestLength(strs []string, shortest int) int { |
||||
for _, s := range strs { |
||||
if candidate := utf8.RuneCountInString(s); candidate < shortest { |
||||
shortest = candidate |
||||
} |
||||
} |
||||
return shortest |
||||
} |
||||
|
||||
func longestLength(strs []string) (longest int) { |
||||
for _, s := range strs { |
||||
if candidate := utf8.RuneCountInString(s); candidate > longest { |
||||
longest = candidate |
||||
} |
||||
} |
||||
return longest |
||||
} |
||||
@ -0,0 +1,19 @@ |
||||
Copyright (c) 2014 Naoya Inada <naoina@kuune.org> |
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy |
||||
of this software and associated documentation files (the "Software"), to deal |
||||
in the Software without restriction, including without limitation the rights |
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
||||
copies of the Software, and to permit persons to whom the Software is |
||||
furnished to do so, subject to the following conditions: |
||||
|
||||
The above copyright notice and this permission notice shall be included in |
||||
all copies or substantial portions of the Software. |
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
||||
THE SOFTWARE. |
||||
@ -0,0 +1,392 @@ |
||||
# TOML parser and encoder library for Golang [](https://travis-ci.org/naoina/toml) |
||||
|
||||
[TOML](https://github.com/toml-lang/toml) parser and encoder library for [Golang](http://golang.org/). |
||||
|
||||
This library is compatible with TOML version [v0.4.0](https://github.com/toml-lang/toml/blob/master/versions/en/toml-v0.4.0.md). |
||||
|
||||
## Installation |
||||
|
||||
go get -u github.com/naoina/toml |
||||
|
||||
## Usage |
||||
|
||||
The following TOML save as `example.toml`. |
||||
|
||||
```toml |
||||
# This is a TOML document. Boom. |
||||
|
||||
title = "TOML Example" |
||||
|
||||
[owner] |
||||
name = "Lance Uppercut" |
||||
dob = 1979-05-27T07:32:00-08:00 # 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] ] |
||||
|
||||
# Line breaks are OK when inside arrays |
||||
hosts = [ |
||||
"alpha", |
||||
"omega" |
||||
] |
||||
``` |
||||
|
||||
Then above TOML will mapping to `tomlConfig` struct using `toml.Unmarshal`. |
||||
|
||||
```go |
||||
package main |
||||
|
||||
import ( |
||||
"io/ioutil" |
||||
"os" |
||||
"time" |
||||
|
||||
"github.com/naoina/toml" |
||||
) |
||||
|
||||
type tomlConfig struct { |
||||
Title string |
||||
Owner struct { |
||||
Name string |
||||
Dob time.Time |
||||
} |
||||
Database struct { |
||||
Server string |
||||
Ports []int |
||||
ConnectionMax uint |
||||
Enabled bool |
||||
} |
||||
Servers map[string]ServerInfo |
||||
Clients struct { |
||||
Data [][]interface{} |
||||
Hosts []string |
||||
} |
||||
} |
||||
|
||||
type ServerInfo struct { |
||||
IP net.IP |
||||
DC string |
||||
} |
||||
|
||||
func main() { |
||||
f, err := os.Open("example.toml") |
||||
if err != nil { |
||||
panic(err) |
||||
} |
||||
defer f.Close() |
||||
var config Config |
||||
if err := toml.NewDecoder(f).Decode(&config); err != nil { |
||||
panic(err) |
||||
} |
||||
|
||||
// then to use the unmarshaled config... |
||||
fmt.Println("IP of server 'alpha':", config.Servers["alpha"].IP) |
||||
} |
||||
``` |
||||
|
||||
## Mappings |
||||
|
||||
A key and value of TOML will map to the corresponding field. |
||||
The fields of struct for mapping must be exported. |
||||
|
||||
The rules of the mapping of key are following: |
||||
|
||||
#### Exact matching |
||||
|
||||
```toml |
||||
timeout_seconds = 256 |
||||
``` |
||||
|
||||
```go |
||||
type Config struct { |
||||
Timeout_seconds int |
||||
} |
||||
``` |
||||
|
||||
#### Camelcase matching |
||||
|
||||
```toml |
||||
server_name = "srv1" |
||||
``` |
||||
|
||||
```go |
||||
type Config struct { |
||||
ServerName string |
||||
} |
||||
``` |
||||
|
||||
#### Uppercase matching |
||||
|
||||
```toml |
||||
ip = "10.0.0.1" |
||||
``` |
||||
|
||||
```go |
||||
type Config struct { |
||||
IP string |
||||
} |
||||
``` |
||||
|
||||
See the following examples for the value mappings. |
||||
|
||||
### String |
||||
|
||||
```toml |
||||
val = "string" |
||||
``` |
||||
|
||||
```go |
||||
type Config struct { |
||||
Val string |
||||
} |
||||
``` |
||||
|
||||
### Integer |
||||
|
||||
```toml |
||||
val = 100 |
||||
``` |
||||
|
||||
```go |
||||
type Config struct { |
||||
Val int |
||||
} |
||||
``` |
||||
|
||||
All types that can be used are following: |
||||
|
||||
* int8 (from `-128` to `127`) |
||||
* int16 (from `-32768` to `32767`) |
||||
* int32 (from `-2147483648` to `2147483647`) |
||||
* int64 (from `-9223372036854775808` to `9223372036854775807`) |
||||
* int (same as `int32` on 32bit environment, or `int64` on 64bit environment) |
||||
* uint8 (from `0` to `255`) |
||||
* uint16 (from `0` to `65535`) |
||||
* uint32 (from `0` to `4294967295`) |
||||
* uint64 (from `0` to `18446744073709551615`) |
||||
* uint (same as `uint` on 32bit environment, or `uint64` on 64bit environment) |
||||
|
||||
### Float |
||||
|
||||
```toml |
||||
val = 3.1415 |
||||
``` |
||||
|
||||
```go |
||||
type Config struct { |
||||
Val float32 |
||||
} |
||||
``` |
||||
|
||||
All types that can be used are following: |
||||
|
||||
* float32 |
||||
* float64 |
||||
|
||||
### Boolean |
||||
|
||||
```toml |
||||
val = true |
||||
``` |
||||
|
||||
```go |
||||
type Config struct { |
||||
Val bool |
||||
} |
||||
``` |
||||
|
||||
### Datetime |
||||
|
||||
```toml |
||||
val = 2014-09-28T21:27:39Z |
||||
``` |
||||
|
||||
```go |
||||
type Config struct { |
||||
Val time.Time |
||||
} |
||||
``` |
||||
|
||||
### Array |
||||
|
||||
```toml |
||||
val = ["a", "b", "c"] |
||||
``` |
||||
|
||||
```go |
||||
type Config struct { |
||||
Val []string |
||||
} |
||||
``` |
||||
|
||||
Also following examples all can be mapped: |
||||
|
||||
```toml |
||||
val1 = [1, 2, 3] |
||||
val2 = [["a", "b"], ["c", "d"]] |
||||
val3 = [[1, 2, 3], ["a", "b", "c"]] |
||||
val4 = [[1, 2, 3], [["a", "b"], [true, false]]] |
||||
``` |
||||
|
||||
```go |
||||
type Config struct { |
||||
Val1 []int |
||||
Val2 [][]string |
||||
Val3 [][]interface{} |
||||
Val4 [][]interface{} |
||||
} |
||||
``` |
||||
|
||||
### Table |
||||
|
||||
```toml |
||||
[server] |
||||
type = "app" |
||||
|
||||
[server.development] |
||||
ip = "10.0.0.1" |
||||
|
||||
[server.production] |
||||
ip = "10.0.0.2" |
||||
``` |
||||
|
||||
```go |
||||
type Config struct { |
||||
Server map[string]Server |
||||
} |
||||
|
||||
type Server struct { |
||||
IP string |
||||
} |
||||
``` |
||||
|
||||
You can also use the following struct instead of map of struct. |
||||
|
||||
```go |
||||
type Config struct { |
||||
Server struct { |
||||
Development Server |
||||
Production Server |
||||
} |
||||
} |
||||
|
||||
type Server struct { |
||||
IP string |
||||
} |
||||
``` |
||||
|
||||
### Array of Tables |
||||
|
||||
```toml |
||||
[[fruit]] |
||||
name = "apple" |
||||
|
||||
[fruit.physical] |
||||
color = "red" |
||||
shape = "round" |
||||
|
||||
[[fruit.variety]] |
||||
name = "red delicious" |
||||
|
||||
[[fruit.variety]] |
||||
name = "granny smith" |
||||
|
||||
[[fruit]] |
||||
name = "banana" |
||||
|
||||
[[fruit.variety]] |
||||
name = "plantain" |
||||
``` |
||||
|
||||
```go |
||||
type Config struct { |
||||
Fruit []struct { |
||||
Name string |
||||
Physical struct { |
||||
Color string |
||||
Shape string |
||||
} |
||||
Variety []struct { |
||||
Name string |
||||
} |
||||
} |
||||
} |
||||
``` |
||||
|
||||
### Using the `encoding.TextUnmarshaler` interface |
||||
|
||||
Package toml supports `encoding.TextUnmarshaler` (and `encoding.TextMarshaler`). You can |
||||
use it to apply custom marshaling rules for certain types. The `UnmarshalText` method is |
||||
called with the value text found in the TOML input. TOML strings are passed unquoted. |
||||
|
||||
```toml |
||||
duration = "10s" |
||||
``` |
||||
|
||||
```go |
||||
import time |
||||
|
||||
type Duration time.Duration |
||||
|
||||
// UnmarshalText implements encoding.TextUnmarshaler |
||||
func (d *Duration) UnmarshalText(data []byte) error { |
||||
duration, err := time.ParseDuration(string(data)) |
||||
if err == nil { |
||||
*d = Duration(duration) |
||||
} |
||||
return err |
||||
} |
||||
|
||||
// MarshalText implements encoding.TextMarshaler |
||||
func (d Duration) MarshalText() ([]byte, error) { |
||||
return []byte(time.Duration(d).String()), nil |
||||
} |
||||
|
||||
type ConfigWithDuration struct { |
||||
Duration Duration |
||||
} |
||||
``` |
||||
### Using the `toml.UnmarshalerRec` interface |
||||
|
||||
You can also override marshaling rules specifically for TOML using the `UnmarshalerRec` |
||||
and `MarshalerRec` interfaces. These are useful if you want to control how structs or |
||||
arrays are handled. You can apply additional validation or set unexported struct fields. |
||||
|
||||
Note: `encoding.TextUnmarshaler` and `encoding.TextMarshaler` should be preferred for |
||||
simple (scalar) values because they're also compatible with other formats like JSON or |
||||
YAML. |
||||
|
||||
[See the UnmarshalerRec example](https://godoc.org/github.com/naoina/toml/#example_UnmarshalerRec). |
||||
|
||||
### Using the `toml.Unmarshaler` interface |
||||
|
||||
If you want to deal with raw TOML syntax, use the `Unmarshaler` and `Marshaler` |
||||
interfaces. Their input and output is raw TOML syntax. As such, these interfaces are |
||||
useful if you want to handle TOML at the syntax level. |
||||
|
||||
[See the Unmarshaler example](https://godoc.org/github.com/naoina/toml/#example_Unmarshaler). |
||||
|
||||
## API documentation |
||||
|
||||
See [Godoc](http://godoc.org/github.com/naoina/toml). |
||||
|
||||
## License |
||||
|
||||
MIT |
||||
@ -0,0 +1,192 @@ |
||||
package ast |
||||
|
||||
import ( |
||||
"strconv" |
||||
"strings" |
||||
"time" |
||||
) |
||||
|
||||
type Position struct { |
||||
Begin int |
||||
End int |
||||
} |
||||
|
||||
type Value interface { |
||||
Pos() int |
||||
End() int |
||||
Source() string |
||||
} |
||||
|
||||
type String struct { |
||||
Position Position |
||||
Value string |
||||
Data []rune |
||||
} |
||||
|
||||
func (s *String) Pos() int { |
||||
return s.Position.Begin |
||||
} |
||||
|
||||
func (s *String) End() int { |
||||
return s.Position.End |
||||
} |
||||
|
||||
func (s *String) Source() string { |
||||
return string(s.Data) |
||||
} |
||||
|
||||
type Integer struct { |
||||
Position Position |
||||
Value string |
||||
Data []rune |
||||
} |
||||
|
||||
func (i *Integer) Pos() int { |
||||
return i.Position.Begin |
||||
} |
||||
|
||||
func (i *Integer) End() int { |
||||
return i.Position.End |
||||
} |
||||
|
||||
func (i *Integer) Source() string { |
||||
return string(i.Data) |
||||
} |
||||
|
||||
func (i *Integer) Int() (int64, error) { |
||||
return strconv.ParseInt(i.Value, 10, 64) |
||||
} |
||||
|
||||
type Float struct { |
||||
Position Position |
||||
Value string |
||||
Data []rune |
||||
} |
||||
|
||||
func (f *Float) Pos() int { |
||||
return f.Position.Begin |
||||
} |
||||
|
||||
func (f *Float) End() int { |
||||
return f.Position.End |
||||
} |
||||
|
||||
func (f *Float) Source() string { |
||||
return string(f.Data) |
||||
} |
||||
|
||||
func (f *Float) Float() (float64, error) { |
||||
return strconv.ParseFloat(f.Value, 64) |
||||
} |
||||
|
||||
type Boolean struct { |
||||
Position Position |
||||
Value string |
||||
Data []rune |
||||
} |
||||
|
||||
func (b *Boolean) Pos() int { |
||||
return b.Position.Begin |
||||
} |
||||
|
||||
func (b *Boolean) End() int { |
||||
return b.Position.End |
||||
} |
||||
|
||||
func (b *Boolean) Source() string { |
||||
return string(b.Data) |
||||
} |
||||
|
||||
func (b *Boolean) Boolean() (bool, error) { |
||||
return strconv.ParseBool(b.Value) |
||||
} |
||||
|
||||
type Datetime struct { |
||||
Position Position |
||||
Value string |
||||
Data []rune |
||||
} |
||||
|
||||
func (d *Datetime) Pos() int { |
||||
return d.Position.Begin |
||||
} |
||||
|
||||
func (d *Datetime) End() int { |
||||
return d.Position.End |
||||
} |
||||
|
||||
func (d *Datetime) Source() string { |
||||
return string(d.Data) |
||||
} |
||||
|
||||
func (d *Datetime) Time() (time.Time, error) { |
||||
switch { |
||||
case !strings.Contains(d.Value, ":"): |
||||
return time.Parse("2006-01-02", d.Value) |
||||
case !strings.Contains(d.Value, "-"): |
||||
return time.Parse("15:04:05.999999999", d.Value) |
||||
default: |
||||
return time.Parse(time.RFC3339Nano, d.Value) |
||||
} |
||||
} |
||||
|
||||
type Array struct { |
||||
Position Position |
||||
Value []Value |
||||
Data []rune |
||||
} |
||||
|
||||
func (a *Array) Pos() int { |
||||
return a.Position.Begin |
||||
} |
||||
|
||||
func (a *Array) End() int { |
||||
return a.Position.End |
||||
} |
||||
|
||||
func (a *Array) Source() string { |
||||
return string(a.Data) |
||||
} |
||||
|
||||
type TableType uint8 |
||||
|
||||
const ( |
||||
TableTypeNormal TableType = iota |
||||
TableTypeArray |
||||
) |
||||
|
||||
var tableTypes = [...]string{ |
||||
"normal", |
||||
"array", |
||||
} |
||||
|
||||
func (t TableType) String() string { |
||||
return tableTypes[t] |
||||
} |
||||
|
||||
type Table struct { |
||||
Position Position |
||||
Line int |
||||
Name string |
||||
Fields map[string]interface{} |
||||
Type TableType |
||||
Data []rune |
||||
} |
||||
|
||||
func (t *Table) Pos() int { |
||||
return t.Position.Begin |
||||
} |
||||
|
||||
func (t *Table) End() int { |
||||
return t.Position.End |
||||
} |
||||
|
||||
func (t *Table) Source() string { |
||||
return string(t.Data) |
||||
} |
||||
|
||||
type KeyValue struct { |
||||
Key string |
||||
Value Value |
||||
Line int |
||||
} |
||||
@ -0,0 +1,86 @@ |
||||
package toml |
||||
|
||||
import ( |
||||
"fmt" |
||||
"io" |
||||
"reflect" |
||||
"strings" |
||||
|
||||
stringutil "github.com/naoina/go-stringutil" |
||||
"github.com/naoina/toml/ast" |
||||
) |
||||
|
||||
// Config contains options for encoding and decoding.
|
||||
type Config struct { |
||||
// NormFieldName is used to match TOML keys to struct fields. The function runs for
|
||||
// both input keys and struct field names and should return a string that makes the
|
||||
// two match. You must set this field to use the decoder.
|
||||
//
|
||||
// Example: The function in the default config removes _ and lowercases all keys. This
|
||||
// allows a key called 'api_key' to match the struct field 'APIKey' because both are
|
||||
// normalized to 'apikey'.
|
||||
//
|
||||
// Note that NormFieldName is not used for fields which define a TOML
|
||||
// key through the struct tag.
|
||||
NormFieldName func(typ reflect.Type, keyOrField string) string |
||||
|
||||
// FieldToKey determines the TOML key of a struct field when encoding.
|
||||
// You must set this field to use the encoder.
|
||||
//
|
||||
// Note that FieldToKey is not used for fields which define a TOML
|
||||
// key through the struct tag.
|
||||
FieldToKey func(typ reflect.Type, field string) string |
||||
|
||||
// MissingField, if non-nil, is called when the decoder encounters a key for which no
|
||||
// matching struct field exists. The default behavior is to return an error.
|
||||
MissingField func(typ reflect.Type, key string) error |
||||
} |
||||
|
||||
// DefaultConfig contains the default options for encoding and decoding.
|
||||
// Snake case (i.e. 'foo_bar') is used for key names.
|
||||
var DefaultConfig = Config{ |
||||
NormFieldName: defaultNormFieldName, |
||||
FieldToKey: snakeCase, |
||||
} |
||||
|
||||
func defaultNormFieldName(typ reflect.Type, s string) string { |
||||
return strings.Replace(strings.ToLower(s), "_", "", -1) |
||||
} |
||||
|
||||
func snakeCase(typ reflect.Type, s string) string { |
||||
return stringutil.ToSnakeCase(s) |
||||
} |
||||
|
||||
func defaultMissingField(typ reflect.Type, key string) error { |
||||
return fmt.Errorf("field corresponding to `%s' is not defined in %v", key, typ) |
||||
} |
||||
|
||||
// NewEncoder returns a new Encoder that writes to w.
|
||||
// It is shorthand for DefaultConfig.NewEncoder(w).
|
||||
func NewEncoder(w io.Writer) *Encoder { |
||||
return DefaultConfig.NewEncoder(w) |
||||
} |
||||
|
||||
// Marshal returns the TOML encoding of v.
|
||||
// It is shorthand for DefaultConfig.Marshal(v).
|
||||
func Marshal(v interface{}) ([]byte, error) { |
||||
return DefaultConfig.Marshal(v) |
||||
} |
||||
|
||||
// Unmarshal parses the TOML data and stores the result in the value pointed to by v.
|
||||
// It is shorthand for DefaultConfig.Unmarshal(data, v).
|
||||
func Unmarshal(data []byte, v interface{}) error { |
||||
return DefaultConfig.Unmarshal(data, v) |
||||
} |
||||
|
||||
// UnmarshalTable applies the contents of an ast.Table to the value pointed at by v.
|
||||
// It is shorthand for DefaultConfig.UnmarshalTable(t, v).
|
||||
func UnmarshalTable(t *ast.Table, v interface{}) error { |
||||
return DefaultConfig.UnmarshalTable(t, v) |
||||
} |
||||
|
||||
// NewDecoder returns a new Decoder that reads from r.
|
||||
// It is shorthand for DefaultConfig.NewDecoder(r).
|
||||
func NewDecoder(r io.Reader) *Decoder { |
||||
return DefaultConfig.NewDecoder(r) |
||||
} |
||||
@ -0,0 +1,478 @@ |
||||
// Package toml encodes and decodes the TOML configuration format using reflection.
|
||||
//
|
||||
// This library is compatible with TOML version v0.4.0.
|
||||
package toml |
||||
|
||||
import ( |
||||
"encoding" |
||||
"fmt" |
||||
"io" |
||||
"io/ioutil" |
||||
"reflect" |
||||
"strconv" |
||||
"strings" |
||||
"time" |
||||
|
||||
"github.com/naoina/toml/ast" |
||||
) |
||||
|
||||
const ( |
||||
tableSeparator = '.' |
||||
) |
||||
|
||||
var ( |
||||
escapeReplacer = strings.NewReplacer( |
||||
"\b", "\\n", |
||||
"\f", "\\f", |
||||
"\n", "\\n", |
||||
"\r", "\\r", |
||||
"\t", "\\t", |
||||
) |
||||
underscoreReplacer = strings.NewReplacer( |
||||
"_", "", |
||||
) |
||||
) |
||||
|
||||
var timeType = reflect.TypeOf(time.Time{}) |
||||
|
||||
// Unmarshal parses the TOML data and stores the result in the value pointed to by v.
|
||||
//
|
||||
// Unmarshal will mapped to v that according to following rules:
|
||||
//
|
||||
// TOML strings to string
|
||||
// TOML integers to any int type
|
||||
// TOML floats to float32 or float64
|
||||
// TOML booleans to bool
|
||||
// TOML datetimes to time.Time
|
||||
// TOML arrays to any type of slice
|
||||
// TOML tables to struct or map
|
||||
// TOML array tables to slice of struct or map
|
||||
func (cfg *Config) Unmarshal(data []byte, v interface{}) error { |
||||
table, err := Parse(data) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
if err := cfg.UnmarshalTable(table, v); err != nil { |
||||
return err |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
// A Decoder reads and decodes TOML from an input stream.
|
||||
type Decoder struct { |
||||
r io.Reader |
||||
cfg *Config |
||||
} |
||||
|
||||
// NewDecoder returns a new Decoder that reads from r.
|
||||
// Note that it reads all from r before parsing it.
|
||||
func (cfg *Config) NewDecoder(r io.Reader) *Decoder { |
||||
return &Decoder{r, cfg} |
||||
} |
||||
|
||||
// Decode parses the TOML data from its input and stores it in the value pointed to by v.
|
||||
// See the documentation for Unmarshal for details about the conversion of TOML into a Go value.
|
||||
func (d *Decoder) Decode(v interface{}) error { |
||||
b, err := ioutil.ReadAll(d.r) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
return d.cfg.Unmarshal(b, v) |
||||
} |
||||
|
||||
// UnmarshalerRec may be implemented by types to customize their behavior when being
|
||||
// unmarshaled from TOML. You can use it to implement custom validation or to set
|
||||
// unexported fields.
|
||||
//
|
||||
// UnmarshalTOML receives a function that can be called to unmarshal the original TOML
|
||||
// value into a field or variable. It is safe to call the function more than once if
|
||||
// necessary.
|
||||
type UnmarshalerRec interface { |
||||
UnmarshalTOML(fn func(interface{}) error) error |
||||
} |
||||
|
||||
// Unmarshaler can be used to capture and process raw TOML source of a table or value.
|
||||
// UnmarshalTOML must copy the input if it wishes to retain it after returning.
|
||||
//
|
||||
// Note: this interface is retained for backwards compatibility. You probably want
|
||||
// to implement encoding.TextUnmarshaler or UnmarshalerRec instead.
|
||||
type Unmarshaler interface { |
||||
UnmarshalTOML(input []byte) error |
||||
} |
||||
|
||||
// UnmarshalTable applies the contents of an ast.Table to the value pointed at by v.
|
||||
//
|
||||
// UnmarshalTable will mapped to v that according to following rules:
|
||||
//
|
||||
// TOML strings to string
|
||||
// TOML integers to any int type
|
||||
// TOML floats to float32 or float64
|
||||
// TOML booleans to bool
|
||||
// TOML datetimes to time.Time
|
||||
// TOML arrays to any type of slice
|
||||
// TOML tables to struct or map
|
||||
// TOML array tables to slice of struct or map
|
||||
func (cfg *Config) UnmarshalTable(t *ast.Table, v interface{}) error { |
||||
rv := reflect.ValueOf(v) |
||||
toplevelMap := rv.Kind() == reflect.Map |
||||
if (!toplevelMap && rv.Kind() != reflect.Ptr) || rv.IsNil() { |
||||
return &invalidUnmarshalError{reflect.TypeOf(v)} |
||||
} |
||||
return unmarshalTable(cfg, rv, t, toplevelMap) |
||||
} |
||||
|
||||
// used for UnmarshalerRec.
|
||||
func unmarshalTableOrValue(cfg *Config, rv reflect.Value, av interface{}) error { |
||||
if (rv.Kind() != reflect.Ptr && rv.Kind() != reflect.Map) || rv.IsNil() { |
||||
return &invalidUnmarshalError{rv.Type()} |
||||
} |
||||
rv = indirect(rv) |
||||
|
||||
switch av.(type) { |
||||
case *ast.KeyValue, *ast.Table, []*ast.Table: |
||||
if err := unmarshalField(cfg, rv, av); err != nil { |
||||
return lineError(fieldLineNumber(av), err) |
||||
} |
||||
return nil |
||||
case ast.Value: |
||||
return setValue(cfg, rv, av.(ast.Value)) |
||||
default: |
||||
panic(fmt.Sprintf("BUG: unhandled AST node type %T", av)) |
||||
} |
||||
} |
||||
|
||||
// unmarshalTable unmarshals the fields of a table into a struct or map.
|
||||
//
|
||||
// toplevelMap is true when rv is an (unadressable) map given to UnmarshalTable. In this
|
||||
// (special) case, the map is used as-is instead of creating a new map.
|
||||
func unmarshalTable(cfg *Config, rv reflect.Value, t *ast.Table, toplevelMap bool) error { |
||||
rv = indirect(rv) |
||||
if err, ok := setUnmarshaler(cfg, rv, t); ok { |
||||
return lineError(t.Line, err) |
||||
} |
||||
switch { |
||||
case rv.Kind() == reflect.Struct: |
||||
fc := makeFieldCache(cfg, rv.Type()) |
||||
for key, fieldAst := range t.Fields { |
||||
fv, fieldName, err := fc.findField(cfg, rv, key) |
||||
if err != nil { |
||||
return lineError(fieldLineNumber(fieldAst), err) |
||||
} |
||||
if fv.IsValid() { |
||||
if err := unmarshalField(cfg, fv, fieldAst); err != nil { |
||||
return lineErrorField(fieldLineNumber(fieldAst), rv.Type().String()+"."+fieldName, err) |
||||
} |
||||
} |
||||
} |
||||
case rv.Kind() == reflect.Map || isEface(rv): |
||||
m := rv |
||||
if !toplevelMap { |
||||
if rv.Kind() == reflect.Interface { |
||||
m = reflect.ValueOf(make(map[string]interface{})) |
||||
} else { |
||||
m = reflect.MakeMap(rv.Type()) |
||||
} |
||||
} |
||||
elemtyp := m.Type().Elem() |
||||
for key, fieldAst := range t.Fields { |
||||
kv, err := unmarshalMapKey(m.Type().Key(), key) |
||||
if err != nil { |
||||
return lineError(fieldLineNumber(fieldAst), err) |
||||
} |
||||
fv := reflect.New(elemtyp).Elem() |
||||
if err := unmarshalField(cfg, fv, fieldAst); err != nil { |
||||
return lineError(fieldLineNumber(fieldAst), err) |
||||
} |
||||
m.SetMapIndex(kv, fv) |
||||
} |
||||
if !toplevelMap { |
||||
rv.Set(m) |
||||
} |
||||
default: |
||||
return lineError(t.Line, &unmarshalTypeError{"table", "struct or map", rv.Type()}) |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
func fieldLineNumber(fieldAst interface{}) int { |
||||
switch av := fieldAst.(type) { |
||||
case *ast.KeyValue: |
||||
return av.Line |
||||
case *ast.Table: |
||||
return av.Line |
||||
case []*ast.Table: |
||||
return av[0].Line |
||||
default: |
||||
panic(fmt.Sprintf("BUG: unhandled node type %T", fieldAst)) |
||||
} |
||||
} |
||||
|
||||
func unmarshalField(cfg *Config, rv reflect.Value, fieldAst interface{}) error { |
||||
switch av := fieldAst.(type) { |
||||
case *ast.KeyValue: |
||||
return setValue(cfg, rv, av.Value) |
||||
case *ast.Table: |
||||
return unmarshalTable(cfg, rv, av, false) |
||||
case []*ast.Table: |
||||
rv = indirect(rv) |
||||
if err, ok := setUnmarshaler(cfg, rv, fieldAst); ok { |
||||
return err |
||||
} |
||||
var slice reflect.Value |
||||
switch { |
||||
case rv.Kind() == reflect.Slice: |
||||
slice = reflect.MakeSlice(rv.Type(), len(av), len(av)) |
||||
case isEface(rv): |
||||
slice = reflect.ValueOf(make([]interface{}, len(av))) |
||||
default: |
||||
return &unmarshalTypeError{"array table", "slice", rv.Type()} |
||||
} |
||||
for i, tbl := range av { |
||||
vv := reflect.New(slice.Type().Elem()).Elem() |
||||
if err := unmarshalTable(cfg, vv, tbl, false); err != nil { |
||||
return err |
||||
} |
||||
slice.Index(i).Set(vv) |
||||
} |
||||
rv.Set(slice) |
||||
default: |
||||
panic(fmt.Sprintf("BUG: unhandled AST node type %T", av)) |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
func unmarshalMapKey(typ reflect.Type, key string) (reflect.Value, error) { |
||||
rv := reflect.New(typ).Elem() |
||||
if u, ok := rv.Addr().Interface().(encoding.TextUnmarshaler); ok { |
||||
return rv, u.UnmarshalText([]byte(key)) |
||||
} |
||||
switch typ.Kind() { |
||||
case reflect.String: |
||||
rv.SetString(key) |
||||
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: |
||||
i, err := strconv.ParseInt(key, 10, int(typ.Size()*8)) |
||||
if err != nil { |
||||
return rv, convertNumError(typ.Kind(), err) |
||||
} |
||||
rv.SetInt(i) |
||||
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: |
||||
i, err := strconv.ParseUint(key, 10, int(typ.Size()*8)) |
||||
if err != nil { |
||||
return rv, convertNumError(typ.Kind(), err) |
||||
} |
||||
rv.SetUint(i) |
||||
default: |
||||
return rv, fmt.Errorf("invalid map key type %s", typ) |
||||
} |
||||
return rv, nil |
||||
} |
||||
|
||||
func setValue(cfg *Config, lhs reflect.Value, val ast.Value) error { |
||||
lhs = indirect(lhs) |
||||
if err, ok := setUnmarshaler(cfg, lhs, val); ok { |
||||
return err |
||||
} |
||||
if err, ok := setTextUnmarshaler(lhs, val); ok { |
||||
return err |
||||
} |
||||
switch v := val.(type) { |
||||
case *ast.Integer: |
||||
return setInt(lhs, v) |
||||
case *ast.Float: |
||||
return setFloat(lhs, v) |
||||
case *ast.String: |
||||
return setString(lhs, v) |
||||
case *ast.Boolean: |
||||
return setBoolean(lhs, v) |
||||
case *ast.Datetime: |
||||
return setDatetime(lhs, v) |
||||
case *ast.Array: |
||||
return setArray(cfg, lhs, v) |
||||
default: |
||||
panic(fmt.Sprintf("BUG: unhandled node type %T", v)) |
||||
} |
||||
} |
||||
|
||||
func indirect(rv reflect.Value) reflect.Value { |
||||
for rv.Kind() == reflect.Ptr { |
||||
if rv.IsNil() { |
||||
rv.Set(reflect.New(rv.Type().Elem())) |
||||
} |
||||
rv = rv.Elem() |
||||
} |
||||
return rv |
||||
} |
||||
|
||||
func setUnmarshaler(cfg *Config, lhs reflect.Value, av interface{}) (error, bool) { |
||||
if lhs.CanAddr() { |
||||
if u, ok := lhs.Addr().Interface().(UnmarshalerRec); ok { |
||||
err := u.UnmarshalTOML(func(v interface{}) error { |
||||
return unmarshalTableOrValue(cfg, reflect.ValueOf(v), av) |
||||
}) |
||||
return err, true |
||||
} |
||||
if u, ok := lhs.Addr().Interface().(Unmarshaler); ok { |
||||
return u.UnmarshalTOML(unmarshalerSource(av)), true |
||||
} |
||||
} |
||||
return nil, false |
||||
} |
||||
|
||||
func unmarshalerSource(av interface{}) []byte { |
||||
var source []byte |
||||
switch av := av.(type) { |
||||
case []*ast.Table: |
||||
for i, tab := range av { |
||||
source = append(source, tab.Source()...) |
||||
if i != len(av)-1 { |
||||
source = append(source, '\n') |
||||
} |
||||
} |
||||
case ast.Value: |
||||
source = []byte(av.Source()) |
||||
default: |
||||
panic(fmt.Sprintf("BUG: unhandled node type %T", av)) |
||||
} |
||||
return source |
||||
} |
||||
|
||||
func setTextUnmarshaler(lhs reflect.Value, val ast.Value) (error, bool) { |
||||
if !lhs.CanAddr() { |
||||
return nil, false |
||||
} |
||||
u, ok := lhs.Addr().Interface().(encoding.TextUnmarshaler) |
||||
if !ok || lhs.Type() == timeType { |
||||
return nil, false |
||||
} |
||||
var data string |
||||
switch val := val.(type) { |
||||
case *ast.Array: |
||||
return &unmarshalTypeError{"array", "", lhs.Type()}, true |
||||
case *ast.String: |
||||
data = val.Value |
||||
default: |
||||
data = val.Source() |
||||
} |
||||
return u.UnmarshalText([]byte(data)), true |
||||
} |
||||
|
||||
func setInt(fv reflect.Value, v *ast.Integer) error { |
||||
k := fv.Kind() |
||||
switch { |
||||
case k >= reflect.Int && k <= reflect.Int64: |
||||
i, err := strconv.ParseInt(v.Value, 10, int(fv.Type().Size()*8)) |
||||
if err != nil { |
||||
return convertNumError(fv.Kind(), err) |
||||
} |
||||
fv.SetInt(i) |
||||
case k >= reflect.Uint && k <= reflect.Uintptr: |
||||
i, err := strconv.ParseUint(v.Value, 10, int(fv.Type().Size()*8)) |
||||
if err != nil { |
||||
return convertNumError(fv.Kind(), err) |
||||
} |
||||
fv.SetUint(i) |
||||
case isEface(fv): |
||||
i, err := strconv.ParseInt(v.Value, 10, 64) |
||||
if err != nil { |
||||
return convertNumError(reflect.Int64, err) |
||||
} |
||||
fv.Set(reflect.ValueOf(i)) |
||||
default: |
||||
return &unmarshalTypeError{"integer", "", fv.Type()} |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
func setFloat(fv reflect.Value, v *ast.Float) error { |
||||
f, err := v.Float() |
||||
if err != nil { |
||||
return err |
||||
} |
||||
switch { |
||||
case fv.Kind() == reflect.Float32 || fv.Kind() == reflect.Float64: |
||||
if fv.OverflowFloat(f) { |
||||
return &overflowError{fv.Kind(), v.Value} |
||||
} |
||||
fv.SetFloat(f) |
||||
case isEface(fv): |
||||
fv.Set(reflect.ValueOf(f)) |
||||
default: |
||||
return &unmarshalTypeError{"float", "", fv.Type()} |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
func setString(fv reflect.Value, v *ast.String) error { |
||||
switch { |
||||
case fv.Kind() == reflect.String: |
||||
fv.SetString(v.Value) |
||||
case isEface(fv): |
||||
fv.Set(reflect.ValueOf(v.Value)) |
||||
default: |
||||
return &unmarshalTypeError{"string", "", fv.Type()} |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
func setBoolean(fv reflect.Value, v *ast.Boolean) error { |
||||
b, _ := v.Boolean() |
||||
switch { |
||||
case fv.Kind() == reflect.Bool: |
||||
fv.SetBool(b) |
||||
case isEface(fv): |
||||
fv.Set(reflect.ValueOf(b)) |
||||
default: |
||||
return &unmarshalTypeError{"boolean", "", fv.Type()} |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
func setDatetime(rv reflect.Value, v *ast.Datetime) error { |
||||
t, err := v.Time() |
||||
if err != nil { |
||||
return err |
||||
} |
||||
if !timeType.AssignableTo(rv.Type()) { |
||||
return &unmarshalTypeError{"datetime", "", rv.Type()} |
||||
} |
||||
rv.Set(reflect.ValueOf(t)) |
||||
return nil |
||||
} |
||||
|
||||
func setArray(cfg *Config, rv reflect.Value, v *ast.Array) error { |
||||
var slicetyp reflect.Type |
||||
switch { |
||||
case rv.Kind() == reflect.Slice: |
||||
slicetyp = rv.Type() |
||||
case isEface(rv): |
||||
slicetyp = reflect.SliceOf(rv.Type()) |
||||
default: |
||||
return &unmarshalTypeError{"array", "slice", rv.Type()} |
||||
} |
||||
|
||||
if len(v.Value) == 0 { |
||||
// Ensure defined slices are always set to a non-nil value.
|
||||
rv.Set(reflect.MakeSlice(slicetyp, 0, 0)) |
||||
return nil |
||||
} |
||||
|
||||
tomltyp := reflect.TypeOf(v.Value[0]) |
||||
slice := reflect.MakeSlice(slicetyp, len(v.Value), len(v.Value)) |
||||
typ := slicetyp.Elem() |
||||
for i, vv := range v.Value { |
||||
if i > 0 && tomltyp != reflect.TypeOf(vv) { |
||||
return errArrayMultiType |
||||
} |
||||
tmp := reflect.New(typ).Elem() |
||||
if err := setValue(cfg, tmp, vv); err != nil { |
||||
return err |
||||
} |
||||
slice.Index(i).Set(tmp) |
||||
} |
||||
rv.Set(slice) |
||||
return nil |
||||
} |
||||
|
||||
func isEface(rv reflect.Value) bool { |
||||
return rv.Kind() == reflect.Interface && rv.Type().NumMethod() == 0 |
||||
} |
||||
@ -0,0 +1,398 @@ |
||||
package toml |
||||
|
||||
import ( |
||||
"bytes" |
||||
"encoding" |
||||
"fmt" |
||||
"io" |
||||
"reflect" |
||||
"sort" |
||||
"strconv" |
||||
"time" |
||||
|
||||
"github.com/naoina/toml/ast" |
||||
) |
||||
|
||||
const ( |
||||
tagOmitempty = "omitempty" |
||||
tagSkip = "-" |
||||
) |
||||
|
||||
// Marshal returns the TOML encoding of v.
|
||||
//
|
||||
// Struct values encode as TOML. Each exported struct field becomes a field of
|
||||
// the TOML structure unless
|
||||
// - the field's tag is "-", or
|
||||
// - the field is empty and its tag specifies the "omitempty" option.
|
||||
//
|
||||
// The "toml" key in the struct field's tag value is the key name, followed by
|
||||
// an optional comma and options. Examples:
|
||||
//
|
||||
// // Field is ignored by this package.
|
||||
// Field int `toml:"-"`
|
||||
//
|
||||
// // Field appears in TOML as key "myName".
|
||||
// Field int `toml:"myName"`
|
||||
//
|
||||
// // Field appears in TOML as key "myName" and the field is omitted from the
|
||||
// // result of encoding if its value is empty.
|
||||
// Field int `toml:"myName,omitempty"`
|
||||
//
|
||||
// // Field appears in TOML as key "field", but the field is skipped if
|
||||
// // empty. Note the leading comma.
|
||||
// Field int `toml:",omitempty"`
|
||||
func (cfg *Config) Marshal(v interface{}) ([]byte, error) { |
||||
buf := new(bytes.Buffer) |
||||
err := cfg.NewEncoder(buf).Encode(v) |
||||
return buf.Bytes(), err |
||||
} |
||||
|
||||
// A Encoder writes TOML to an output stream.
|
||||
type Encoder struct { |
||||
w io.Writer |
||||
cfg *Config |
||||
} |
||||
|
||||
// NewEncoder returns a new Encoder that writes to w.
|
||||
func (cfg *Config) NewEncoder(w io.Writer) *Encoder { |
||||
return &Encoder{w, cfg} |
||||
} |
||||
|
||||
// Encode writes the TOML of v to the stream.
|
||||
// See the documentation for Marshal for details about the conversion of Go values to TOML.
|
||||
func (e *Encoder) Encode(v interface{}) error { |
||||
rv := reflect.ValueOf(v) |
||||
for rv.Kind() == reflect.Ptr { |
||||
if rv.IsNil() { |
||||
return &marshalNilError{rv.Type()} |
||||
} |
||||
rv = rv.Elem() |
||||
} |
||||
buf := &tableBuf{typ: ast.TableTypeNormal} |
||||
var err error |
||||
switch rv.Kind() { |
||||
case reflect.Struct: |
||||
err = buf.structFields(e.cfg, rv) |
||||
case reflect.Map: |
||||
err = buf.mapFields(e.cfg, rv) |
||||
default: |
||||
err = &marshalTableError{rv.Type()} |
||||
} |
||||
if err != nil { |
||||
return err |
||||
} |
||||
return buf.writeTo(e.w, "") |
||||
} |
||||
|
||||
// Marshaler can be implemented to override the encoding of TOML values. The returned text
|
||||
// must be a simple TOML value (i.e. not a table) and is inserted into marshaler output.
|
||||
//
|
||||
// This interface exists for backwards-compatibility reasons. You probably want to
|
||||
// implement encoding.TextMarshaler or MarshalerRec instead.
|
||||
type Marshaler interface { |
||||
MarshalTOML() ([]byte, error) |
||||
} |
||||
|
||||
// MarshalerRec can be implemented to override the TOML encoding of a type.
|
||||
// The returned value is marshaled in place of the receiver.
|
||||
type MarshalerRec interface { |
||||
MarshalTOML() (interface{}, error) |
||||
} |
||||
|
||||
type tableBuf struct { |
||||
name string // already escaped / quoted
|
||||
body []byte |
||||
children []*tableBuf |
||||
typ ast.TableType |
||||
arrayDepth int |
||||
} |
||||
|
||||
func (b *tableBuf) writeTo(w io.Writer, prefix string) error { |
||||
key := b.name // TODO: escape dots
|
||||
if prefix != "" { |
||||
key = prefix + "." + key |
||||
} |
||||
|
||||
if b.name != "" { |
||||
head := "[" + key + "]" |
||||
if b.typ == ast.TableTypeArray { |
||||
head = "[" + head + "]" |
||||
} |
||||
head += "\n" |
||||
if _, err := io.WriteString(w, head); err != nil { |
||||
return err |
||||
} |
||||
} |
||||
if _, err := w.Write(b.body); err != nil { |
||||
return err |
||||
} |
||||
|
||||
for i, child := range b.children { |
||||
if len(b.body) > 0 || i > 0 { |
||||
if _, err := w.Write([]byte("\n")); err != nil { |
||||
return err |
||||
} |
||||
} |
||||
if err := child.writeTo(w, key); err != nil { |
||||
return err |
||||
} |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
func (b *tableBuf) newChild(name string) *tableBuf { |
||||
child := &tableBuf{name: quoteName(name), typ: ast.TableTypeNormal} |
||||
if b.arrayDepth > 0 { |
||||
child.typ = ast.TableTypeArray |
||||
} |
||||
return child |
||||
} |
||||
|
||||
func (b *tableBuf) addChild(child *tableBuf) { |
||||
// Empty table elision: we can avoid writing a table that doesn't have any keys on its
|
||||
// own. Array tables can't be elided because they define array elements (which would
|
||||
// be missing if elided).
|
||||
if len(child.body) == 0 && child.typ == ast.TableTypeNormal { |
||||
for _, gchild := range child.children { |
||||
gchild.name = child.name + "." + gchild.name |
||||
b.addChild(gchild) |
||||
} |
||||
return |
||||
} |
||||
b.children = append(b.children, child) |
||||
} |
||||
|
||||
func (b *tableBuf) structFields(cfg *Config, rv reflect.Value) error { |
||||
rt := rv.Type() |
||||
for i := 0; i < rv.NumField(); i++ { |
||||
ft := rt.Field(i) |
||||
if ft.PkgPath != "" && !ft.Anonymous { // not exported
|
||||
continue |
||||
} |
||||
name, rest := extractTag(ft.Tag.Get(fieldTagName)) |
||||
if name == tagSkip { |
||||
continue |
||||
} |
||||
fv := rv.Field(i) |
||||
if rest == tagOmitempty && isEmptyValue(fv) { |
||||
continue |
||||
} |
||||
if name == "" { |
||||
name = cfg.FieldToKey(rt, ft.Name) |
||||
} |
||||
if err := b.field(cfg, name, fv); err != nil { |
||||
return err |
||||
} |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
type mapKeyList []struct { |
||||
key string |
||||
value reflect.Value |
||||
} |
||||
|
||||
func (l mapKeyList) Len() int { return len(l) } |
||||
func (l mapKeyList) Swap(i, j int) { l[i], l[j] = l[j], l[i] } |
||||
func (l mapKeyList) Less(i, j int) bool { return l[i].key < l[j].key } |
||||
|
||||
func (b *tableBuf) mapFields(cfg *Config, rv reflect.Value) error { |
||||
keys := rv.MapKeys() |
||||
keylist := make(mapKeyList, len(keys)) |
||||
for i, key := range keys { |
||||
var err error |
||||
keylist[i].key, err = encodeMapKey(key) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
keylist[i].value = rv.MapIndex(key) |
||||
} |
||||
sort.Sort(keylist) |
||||
|
||||
for _, kv := range keylist { |
||||
if err := b.field(cfg, kv.key, kv.value); err != nil { |
||||
return err |
||||
} |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
func (b *tableBuf) field(cfg *Config, name string, rv reflect.Value) error { |
||||
off := len(b.body) |
||||
b.body = append(b.body, quoteName(name)...) |
||||
b.body = append(b.body, " = "...) |
||||
isTable, err := b.value(cfg, rv, name) |
||||
if isTable { |
||||
b.body = b.body[:off] // rub out "key ="
|
||||
} else { |
||||
b.body = append(b.body, '\n') |
||||
} |
||||
return err |
||||
} |
||||
|
||||
func (b *tableBuf) value(cfg *Config, rv reflect.Value, name string) (bool, error) { |
||||
isMarshaler, isTable, err := b.marshaler(cfg, rv, name) |
||||
if isMarshaler { |
||||
return isTable, err |
||||
} |
||||
switch rv.Kind() { |
||||
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: |
||||
b.body = strconv.AppendInt(b.body, rv.Int(), 10) |
||||
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: |
||||
b.body = strconv.AppendUint(b.body, rv.Uint(), 10) |
||||
case reflect.Float32, reflect.Float64: |
||||
b.body = strconv.AppendFloat(b.body, rv.Float(), 'e', -1, 64) |
||||
case reflect.Bool: |
||||
b.body = strconv.AppendBool(b.body, rv.Bool()) |
||||
case reflect.String: |
||||
b.body = strconv.AppendQuote(b.body, rv.String()) |
||||
case reflect.Ptr, reflect.Interface: |
||||
if rv.IsNil() { |
||||
return false, &marshalNilError{rv.Type()} |
||||
} |
||||
return b.value(cfg, rv.Elem(), name) |
||||
case reflect.Slice, reflect.Array: |
||||
rvlen := rv.Len() |
||||
if rvlen == 0 { |
||||
b.body = append(b.body, '[', ']') |
||||
return false, nil |
||||
} |
||||
|
||||
b.arrayDepth++ |
||||
wroteElem := false |
||||
b.body = append(b.body, '[') |
||||
for i := 0; i < rvlen; i++ { |
||||
isTable, err := b.value(cfg, rv.Index(i), name) |
||||
if err != nil { |
||||
return isTable, err |
||||
} |
||||
wroteElem = wroteElem || !isTable |
||||
if wroteElem { |
||||
if i < rvlen-1 { |
||||
b.body = append(b.body, ',', ' ') |
||||
} else { |
||||
b.body = append(b.body, ']') |
||||
} |
||||
} |
||||
} |
||||
if !wroteElem { |
||||
b.body = b.body[:len(b.body)-1] // rub out '['
|
||||
} |
||||
b.arrayDepth-- |
||||
return !wroteElem, nil |
||||
case reflect.Struct: |
||||
child := b.newChild(name) |
||||
err := child.structFields(cfg, rv) |
||||
b.addChild(child) |
||||
return true, err |
||||
case reflect.Map: |
||||
child := b.newChild(name) |
||||
err := child.mapFields(cfg, rv) |
||||
b.addChild(child) |
||||
return true, err |
||||
default: |
||||
return false, fmt.Errorf("toml: marshal: unsupported type %v", rv.Kind()) |
||||
} |
||||
return false, nil |
||||
} |
||||
|
||||
func (b *tableBuf) marshaler(cfg *Config, rv reflect.Value, name string) (handled, isTable bool, err error) { |
||||
switch t := rv.Interface().(type) { |
||||
case encoding.TextMarshaler: |
||||
enc, err := t.MarshalText() |
||||
if err != nil { |
||||
return true, false, err |
||||
} |
||||
b.body = encodeTextMarshaler(b.body, string(enc)) |
||||
return true, false, nil |
||||
case MarshalerRec: |
||||
newval, err := t.MarshalTOML() |
||||
if err != nil { |
||||
return true, false, err |
||||
} |
||||
isTable, err = b.value(cfg, reflect.ValueOf(newval), name) |
||||
return true, isTable, err |
||||
case Marshaler: |
||||
enc, err := t.MarshalTOML() |
||||
if err != nil { |
||||
return true, false, err |
||||
} |
||||
b.body = append(b.body, enc...) |
||||
return true, false, nil |
||||
} |
||||
return false, false, nil |
||||
} |
||||
|
||||
func encodeTextMarshaler(buf []byte, v string) []byte { |
||||
// Emit the value without quotes if possible.
|
||||
if v == "true" || v == "false" { |
||||
return append(buf, v...) |
||||
} else if _, err := time.Parse(time.RFC3339Nano, v); err == nil { |
||||
return append(buf, v...) |
||||
} else if _, err := strconv.ParseInt(v, 10, 64); err == nil { |
||||
return append(buf, v...) |
||||
} else if _, err := strconv.ParseUint(v, 10, 64); err == nil { |
||||
return append(buf, v...) |
||||
} else if _, err := strconv.ParseFloat(v, 64); err == nil { |
||||
return append(buf, v...) |
||||
} |
||||
return strconv.AppendQuote(buf, v) |
||||
} |
||||
|
||||
func encodeMapKey(rv reflect.Value) (string, error) { |
||||
if rv.Kind() == reflect.String { |
||||
return rv.String(), nil |
||||
} |
||||
if tm, ok := rv.Interface().(encoding.TextMarshaler); ok { |
||||
b, err := tm.MarshalText() |
||||
return string(b), err |
||||
} |
||||
switch rv.Kind() { |
||||
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: |
||||
return strconv.FormatInt(rv.Int(), 10), nil |
||||
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: |
||||
return strconv.FormatUint(rv.Uint(), 10), nil |
||||
} |
||||
return "", fmt.Errorf("toml: invalid map key type %v", rv.Type()) |
||||
} |
||||
|
||||
func isEmptyValue(v reflect.Value) bool { |
||||
switch v.Kind() { |
||||
case reflect.Array: |
||||
// encoding/json treats all arrays with non-zero length as non-empty. We check the
|
||||
// array content here because zero-length arrays are almost never used.
|
||||
len := v.Len() |
||||
for i := 0; i < len; i++ { |
||||
if !isEmptyValue(v.Index(i)) { |
||||
return false |
||||
} |
||||
} |
||||
return true |
||||
case reflect.Map, reflect.Slice, reflect.String: |
||||
return v.Len() == 0 |
||||
case reflect.Bool: |
||||
return !v.Bool() |
||||
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: |
||||
return v.Int() == 0 |
||||
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: |
||||
return v.Uint() == 0 |
||||
case reflect.Float32, reflect.Float64: |
||||
return v.Float() == 0 |
||||
case reflect.Interface, reflect.Ptr: |
||||
return v.IsNil() |
||||
} |
||||
return false |
||||
} |
||||
|
||||
func quoteName(s string) string { |
||||
if len(s) == 0 { |
||||
return strconv.Quote(s) |
||||
} |
||||
for _, r := range s { |
||||
if r >= '0' && r <= '9' || r >= 'A' && r <= 'Z' || r >= 'a' && r <= 'z' || r == '-' || r == '_' { |
||||
continue |
||||
} |
||||
return strconv.Quote(s) |
||||
} |
||||
return s |
||||
} |
||||
@ -0,0 +1,107 @@ |
||||
package toml |
||||
|
||||
import ( |
||||
"errors" |
||||
"fmt" |
||||
"reflect" |
||||
"strconv" |
||||
) |
||||
|
||||
var ( |
||||
errArrayMultiType = errors.New("array can't contain multiple types") |
||||
) |
||||
|
||||
// LineError is returned by Unmarshal, UnmarshalTable and Parse
|
||||
// if the error is local to a line.
|
||||
type LineError struct { |
||||
Line int |
||||
StructField string |
||||
Err error |
||||
} |
||||
|
||||
func (err *LineError) Error() string { |
||||
field := "" |
||||
if err.StructField != "" { |
||||
field = "(" + err.StructField + ") " |
||||
} |
||||
return fmt.Sprintf("line %d: %s%v", err.Line, field, err.Err) |
||||
} |
||||
|
||||
func lineError(line int, err error) error { |
||||
if err == nil { |
||||
return nil |
||||
} |
||||
if _, ok := err.(*LineError); ok { |
||||
return err |
||||
} |
||||
return &LineError{Line: line, Err: err} |
||||
} |
||||
|
||||
func lineErrorField(line int, field string, err error) error { |
||||
if lerr, ok := err.(*LineError); ok { |
||||
return lerr |
||||
} else if err != nil { |
||||
err = &LineError{Line: line, StructField: field, Err: err} |
||||
} |
||||
return err |
||||
} |
||||
|
||||
type overflowError struct { |
||||
kind reflect.Kind |
||||
v string |
||||
} |
||||
|
||||
func (err *overflowError) Error() string { |
||||
return fmt.Sprintf("value %s is out of range for %v", err.v, err.kind) |
||||
} |
||||
|
||||
func convertNumError(kind reflect.Kind, err error) error { |
||||
if numerr, ok := err.(*strconv.NumError); ok && numerr.Err == strconv.ErrRange { |
||||
return &overflowError{kind, numerr.Num} |
||||
} |
||||
return err |
||||
} |
||||
|
||||
type invalidUnmarshalError struct { |
||||
typ reflect.Type |
||||
} |
||||
|
||||
func (err *invalidUnmarshalError) Error() string { |
||||
if err.typ == nil { |
||||
return "toml: Unmarshal(nil)" |
||||
} |
||||
if err.typ.Kind() != reflect.Ptr { |
||||
return "toml: Unmarshal(non-pointer " + err.typ.String() + ")" |
||||
} |
||||
return "toml: Unmarshal(nil " + err.typ.String() + ")" |
||||
} |
||||
|
||||
type unmarshalTypeError struct { |
||||
what string |
||||
want string |
||||
typ reflect.Type |
||||
} |
||||
|
||||
func (err *unmarshalTypeError) Error() string { |
||||
msg := fmt.Sprintf("cannot unmarshal TOML %s into %s", err.what, err.typ) |
||||
if err.want != "" { |
||||
msg += " (need " + err.want + ")" |
||||
} |
||||
return msg |
||||
} |
||||
|
||||
type marshalNilError struct { |
||||
typ reflect.Type |
||||
} |
||||
|
||||
func (err *marshalNilError) Error() string { |
||||
return fmt.Sprintf("toml: cannot marshal nil %s", err.typ) |
||||
} |
||||
|
||||
type marshalTableError struct { |
||||
typ reflect.Type |
||||
} |
||||
|
||||
func (err *marshalTableError) Error() string { |
||||
return fmt.Sprintf("toml: cannot marshal %s as table, want struct or map type", err.typ) |
||||
} |
||||
@ -0,0 +1,376 @@ |
||||
package toml |
||||
|
||||
import ( |
||||
"errors" |
||||
"fmt" |
||||
"strconv" |
||||
"strings" |
||||
|
||||
"github.com/naoina/toml/ast" |
||||
) |
||||
|
||||
// The parser is generated by github.com/pointlander/peg. To regenerate it, do:
|
||||
//
|
||||
// go get -u github.com/pointlander/peg
|
||||
// go generate .
|
||||
|
||||
//go:generate peg -switch -inline parse.peg
|
||||
|
||||
var errParse = errors.New("invalid TOML syntax") |
||||
|
||||
// Parse returns an AST representation of TOML.
|
||||
// The toplevel is represented by a table.
|
||||
func Parse(data []byte) (*ast.Table, error) { |
||||
d := &parseState{p: &tomlParser{Buffer: string(data)}} |
||||
d.init() |
||||
|
||||
if err := d.parse(); err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
return d.p.toml.table, nil |
||||
} |
||||
|
||||
type parseState struct { |
||||
p *tomlParser |
||||
} |
||||
|
||||
func (d *parseState) init() { |
||||
d.p.Init() |
||||
d.p.toml.init(d.p.buffer) |
||||
} |
||||
|
||||
func (d *parseState) parse() error { |
||||
if err := d.p.Parse(); err != nil { |
||||
if err, ok := err.(*parseError); ok { |
||||
return lineError(err.Line(), errParse) |
||||
} |
||||
return err |
||||
} |
||||
return d.execute() |
||||
} |
||||
|
||||
func (d *parseState) execute() (err error) { |
||||
defer func() { |
||||
if e := recover(); e != nil { |
||||
lerr, ok := e.(*LineError) |
||||
if !ok { |
||||
panic(e) |
||||
} |
||||
err = lerr |
||||
} |
||||
}() |
||||
d.p.Execute() |
||||
return nil |
||||
} |
||||
|
||||
func (e *parseError) Line() int { |
||||
tokens := []token32{e.max} |
||||
positions, p := make([]int, 2*len(tokens)), 0 |
||||
for _, token := range tokens { |
||||
positions[p], p = int(token.begin), p+1 |
||||
positions[p], p = int(token.end), p+1 |
||||
} |
||||
for _, t := range translatePositions(e.p.buffer, positions) { |
||||
if e.p.line < t.line { |
||||
e.p.line = t.line |
||||
} |
||||
} |
||||
return e.p.line |
||||
} |
||||
|
||||
type stack struct { |
||||
key string |
||||
table *ast.Table |
||||
} |
||||
|
||||
type array struct { |
||||
parent *array |
||||
child *array |
||||
current *ast.Array |
||||
line int |
||||
} |
||||
|
||||
type toml struct { |
||||
table *ast.Table |
||||
line int |
||||
currentTable *ast.Table |
||||
s string |
||||
key string |
||||
val ast.Value |
||||
arr *array |
||||
stack []*stack |
||||
skip bool |
||||
} |
||||
|
||||
func (p *toml) init(data []rune) { |
||||
p.line = 1 |
||||
p.table = p.newTable(ast.TableTypeNormal, "") |
||||
p.table.Position.End = len(data) - 1 |
||||
p.table.Data = data[:len(data)-1] // truncate the end_symbol added by PEG parse generator.
|
||||
p.currentTable = p.table |
||||
} |
||||
|
||||
func (p *toml) Error(err error) { |
||||
panic(lineError(p.line, err)) |
||||
} |
||||
|
||||
func (p *tomlParser) SetTime(begin, end int) { |
||||
p.val = &ast.Datetime{ |
||||
Position: ast.Position{Begin: begin, End: end}, |
||||
Data: p.buffer[begin:end], |
||||
Value: string(p.buffer[begin:end]), |
||||
} |
||||
} |
||||
|
||||
func (p *tomlParser) SetFloat64(begin, end int) { |
||||
p.val = &ast.Float{ |
||||
Position: ast.Position{Begin: begin, End: end}, |
||||
Data: p.buffer[begin:end], |
||||
Value: underscoreReplacer.Replace(string(p.buffer[begin:end])), |
||||
} |
||||
} |
||||
|
||||
func (p *tomlParser) SetInt64(begin, end int) { |
||||
p.val = &ast.Integer{ |
||||
Position: ast.Position{Begin: begin, End: end}, |
||||
Data: p.buffer[begin:end], |
||||
Value: underscoreReplacer.Replace(string(p.buffer[begin:end])), |
||||
} |
||||
} |
||||
|
||||
func (p *tomlParser) SetString(begin, end int) { |
||||
p.val = &ast.String{ |
||||
Position: ast.Position{Begin: begin, End: end}, |
||||
Data: p.buffer[begin:end], |
||||
Value: p.s, |
||||
} |
||||
p.s = "" |
||||
} |
||||
|
||||
func (p *tomlParser) SetBool(begin, end int) { |
||||
p.val = &ast.Boolean{ |
||||
Position: ast.Position{Begin: begin, End: end}, |
||||
Data: p.buffer[begin:end], |
||||
Value: string(p.buffer[begin:end]), |
||||
} |
||||
} |
||||
|
||||
func (p *tomlParser) StartArray() { |
||||
if p.arr == nil { |
||||
p.arr = &array{line: p.line, current: &ast.Array{}} |
||||
return |
||||
} |
||||
p.arr.child = &array{parent: p.arr, line: p.line, current: &ast.Array{}} |
||||
p.arr = p.arr.child |
||||
} |
||||
|
||||
func (p *tomlParser) AddArrayVal() { |
||||
if p.arr.current == nil { |
||||
p.arr.current = &ast.Array{} |
||||
} |
||||
p.arr.current.Value = append(p.arr.current.Value, p.val) |
||||
} |
||||
|
||||
func (p *tomlParser) SetArray(begin, end int) { |
||||
p.arr.current.Position = ast.Position{Begin: begin, End: end} |
||||
p.arr.current.Data = p.buffer[begin:end] |
||||
p.val = p.arr.current |
||||
p.arr = p.arr.parent |
||||
} |
||||
|
||||
func (p *toml) SetTable(buf []rune, begin, end int) { |
||||
p.setTable(p.table, buf, begin, end) |
||||
} |
||||
|
||||
func (p *toml) setTable(parent *ast.Table, buf []rune, begin, end int) { |
||||
name := string(buf[begin:end]) |
||||
names := splitTableKey(name) |
||||
parent, err := p.lookupTable(parent, names[:len(names)-1]) |
||||
if err != nil { |
||||
p.Error(err) |
||||
} |
||||
last := names[len(names)-1] |
||||
tbl := p.newTable(ast.TableTypeNormal, last) |
||||
switch v := parent.Fields[last].(type) { |
||||
case nil: |
||||
parent.Fields[last] = tbl |
||||
case []*ast.Table: |
||||
p.Error(fmt.Errorf("table `%s' is in conflict with array table in line %d", name, v[0].Line)) |
||||
case *ast.Table: |
||||
if (v.Position == ast.Position{}) { |
||||
// This table was created as an implicit parent.
|
||||
// Replace it with the real defined table.
|
||||
tbl.Fields = v.Fields |
||||
parent.Fields[last] = tbl |
||||
} else { |
||||
p.Error(fmt.Errorf("table `%s' is in conflict with table in line %d", name, v.Line)) |
||||
} |
||||
case *ast.KeyValue: |
||||
p.Error(fmt.Errorf("table `%s' is in conflict with line %d", name, v.Line)) |
||||
default: |
||||
p.Error(fmt.Errorf("BUG: table `%s' is in conflict but it's unknown type `%T'", last, v)) |
||||
} |
||||
p.currentTable = tbl |
||||
} |
||||
|
||||
func (p *toml) newTable(typ ast.TableType, name string) *ast.Table { |
||||
return &ast.Table{ |
||||
Line: p.line, |
||||
Name: name, |
||||
Type: typ, |
||||
Fields: make(map[string]interface{}), |
||||
} |
||||
} |
||||
|
||||
func (p *tomlParser) SetTableString(begin, end int) { |
||||
p.currentTable.Data = p.buffer[begin:end] |
||||
p.currentTable.Position.Begin = begin |
||||
p.currentTable.Position.End = end |
||||
} |
||||
|
||||
func (p *toml) SetArrayTable(buf []rune, begin, end int) { |
||||
p.setArrayTable(p.table, buf, begin, end) |
||||
} |
||||
|
||||
func (p *toml) setArrayTable(parent *ast.Table, buf []rune, begin, end int) { |
||||
name := string(buf[begin:end]) |
||||
names := splitTableKey(name) |
||||
parent, err := p.lookupTable(parent, names[:len(names)-1]) |
||||
if err != nil { |
||||
p.Error(err) |
||||
} |
||||
last := names[len(names)-1] |
||||
tbl := p.newTable(ast.TableTypeArray, last) |
||||
switch v := parent.Fields[last].(type) { |
||||
case nil: |
||||
parent.Fields[last] = []*ast.Table{tbl} |
||||
case []*ast.Table: |
||||
parent.Fields[last] = append(v, tbl) |
||||
case *ast.Table: |
||||
p.Error(fmt.Errorf("array table `%s' is in conflict with table in line %d", name, v.Line)) |
||||
case *ast.KeyValue: |
||||
p.Error(fmt.Errorf("array table `%s' is in conflict with line %d", name, v.Line)) |
||||
default: |
||||
p.Error(fmt.Errorf("BUG: array table `%s' is in conflict but it's unknown type `%T'", name, v)) |
||||
} |
||||
p.currentTable = tbl |
||||
} |
||||
|
||||
func (p *toml) StartInlineTable() { |
||||
p.skip = false |
||||
p.stack = append(p.stack, &stack{p.key, p.currentTable}) |
||||
buf := []rune(p.key) |
||||
if p.arr == nil { |
||||
p.setTable(p.currentTable, buf, 0, len(buf)) |
||||
} else { |
||||
p.setArrayTable(p.currentTable, buf, 0, len(buf)) |
||||
} |
||||
} |
||||
|
||||
func (p *toml) EndInlineTable() { |
||||
st := p.stack[len(p.stack)-1] |
||||
p.key, p.currentTable = st.key, st.table |
||||
p.stack[len(p.stack)-1] = nil |
||||
p.stack = p.stack[:len(p.stack)-1] |
||||
p.skip = true |
||||
} |
||||
|
||||
func (p *toml) AddLineCount(i int) { |
||||
p.line += i |
||||
} |
||||
|
||||
func (p *toml) SetKey(buf []rune, begin, end int) { |
||||
p.key = string(buf[begin:end]) |
||||
} |
||||
|
||||
func (p *toml) AddKeyValue() { |
||||
if p.skip { |
||||
p.skip = false |
||||
return |
||||
} |
||||
if val, exists := p.currentTable.Fields[p.key]; exists { |
||||
switch v := val.(type) { |
||||
case *ast.Table: |
||||
p.Error(fmt.Errorf("key `%s' is in conflict with table in line %d", p.key, v.Line)) |
||||
case *ast.KeyValue: |
||||
p.Error(fmt.Errorf("key `%s' is in conflict with line %xd", p.key, v.Line)) |
||||
default: |
||||
p.Error(fmt.Errorf("BUG: key `%s' is in conflict but it's unknown type `%T'", p.key, v)) |
||||
} |
||||
} |
||||
p.currentTable.Fields[p.key] = &ast.KeyValue{Key: p.key, Value: p.val, Line: p.line} |
||||
} |
||||
|
||||
func (p *toml) SetBasicString(buf []rune, begin, end int) { |
||||
p.s = p.unquote(string(buf[begin:end])) |
||||
} |
||||
|
||||
func (p *toml) SetMultilineString() { |
||||
p.s = p.unquote(`"` + escapeReplacer.Replace(strings.TrimLeft(p.s, "\r\n")) + `"`) |
||||
} |
||||
|
||||
func (p *toml) AddMultilineBasicBody(buf []rune, begin, end int) { |
||||
p.s += string(buf[begin:end]) |
||||
} |
||||
|
||||
func (p *toml) SetLiteralString(buf []rune, begin, end int) { |
||||
p.s = string(buf[begin:end]) |
||||
} |
||||
|
||||
func (p *toml) SetMultilineLiteralString(buf []rune, begin, end int) { |
||||
p.s = strings.TrimLeft(string(buf[begin:end]), "\r\n") |
||||
} |
||||
|
||||
func (p *toml) unquote(s string) string { |
||||
s, err := strconv.Unquote(s) |
||||
if err != nil { |
||||
p.Error(err) |
||||
} |
||||
return s |
||||
} |
||||
|
||||
func (p *toml) lookupTable(t *ast.Table, keys []string) (*ast.Table, error) { |
||||
for _, s := range keys { |
||||
val, exists := t.Fields[s] |
||||
if !exists { |
||||
tbl := p.newTable(ast.TableTypeNormal, s) |
||||
t.Fields[s] = tbl |
||||
t = tbl |
||||
continue |
||||
} |
||||
switch v := val.(type) { |
||||
case *ast.Table: |
||||
t = v |
||||
case []*ast.Table: |
||||
t = v[len(v)-1] |
||||
case *ast.KeyValue: |
||||
return nil, fmt.Errorf("key `%s' is in conflict with line %d", s, v.Line) |
||||
default: |
||||
return nil, fmt.Errorf("BUG: key `%s' is in conflict but it's unknown type `%T'", s, v) |
||||
} |
||||
} |
||||
return t, nil |
||||
} |
||||
|
||||
func splitTableKey(tk string) []string { |
||||
key := make([]byte, 0, 1) |
||||
keys := make([]string, 0, 1) |
||||
inQuote := false |
||||
for i := 0; i < len(tk); i++ { |
||||
k := tk[i] |
||||
switch { |
||||
case k == tableSeparator && !inQuote: |
||||
keys = append(keys, string(key)) |
||||
key = key[:0] // reuse buffer.
|
||||
case k == '"': |
||||
inQuote = !inQuote |
||||
case (k == ' ' || k == '\t') && !inQuote: |
||||
// skip.
|
||||
default: |
||||
key = append(key, k) |
||||
} |
||||
} |
||||
keys = append(keys, string(key)) |
||||
return keys |
||||
} |
||||
@ -0,0 +1,145 @@ |
||||
package toml |
||||
|
||||
type tomlParser Peg { |
||||
toml |
||||
} |
||||
|
||||
TOML <- Expression (newline Expression)* newline? !. { _ = buffer } |
||||
|
||||
Expression <- ( |
||||
<ws table ws comment? (wsnl keyval ws comment?)*> { p.SetTableString(begin, end) } |
||||
/ ws keyval ws comment? |
||||
/ ws comment? |
||||
/ ws |
||||
) |
||||
|
||||
newline <- <[\r\n]+> { p.AddLineCount(end - begin) } |
||||
|
||||
ws <- [ \t]* |
||||
wsnl <- ( |
||||
[ \t] |
||||
/ <[\r\n]> { p.AddLineCount(end - begin) } |
||||
)* |
||||
|
||||
comment <- '#' <[\t -\0x10FFFF]*> |
||||
|
||||
keyval <- key ws '=' ws val { p.AddKeyValue() } |
||||
|
||||
key <- bareKey / quotedKey |
||||
|
||||
bareKey <- <[0-9A-Za-z\-_]+> { p.SetKey(p.buffer, begin, end) } |
||||
|
||||
quotedKey <- '"' <basicChar+> '"' { p.SetKey(p.buffer, begin-1, end+1) } |
||||
|
||||
val <- ( |
||||
<datetime> { p.SetTime(begin, end) } |
||||
/ <float> { p.SetFloat64(begin, end) } |
||||
/ <integer> { p.SetInt64(begin, end) } |
||||
/ <string> { p.SetString(begin, end) } |
||||
/ <boolean> { p.SetBool(begin, end) } |
||||
/ <array> { p.SetArray(begin, end) } |
||||
/ inlineTable |
||||
) |
||||
|
||||
table <- stdTable / arrayTable |
||||
|
||||
stdTable <- '[' ws <tableKey> ws ']' { p.SetTable(p.buffer, begin, end) } |
||||
|
||||
arrayTable <- '[[' ws <tableKey> ws ']]' { p.SetArrayTable(p.buffer, begin, end) } |
||||
|
||||
inlineTable <- ( |
||||
'{' { p.StartInlineTable() } |
||||
ws inlineTableKeyValues ws |
||||
'}' { p.EndInlineTable() } |
||||
) |
||||
|
||||
inlineTableKeyValues <- (keyval inlineTableValSep?)* |
||||
|
||||
tableKey <- key (tableKeySep key)* |
||||
|
||||
tableKeySep <- ws '.' ws |
||||
|
||||
inlineTableValSep <- ws ',' ws |
||||
|
||||
integer <- [\-+]? int |
||||
int <- [1-9] (digit / '_' digit)+ / digit |
||||
|
||||
float <- integer (frac exp? / frac? exp) |
||||
frac <- '.' digit (digit / '_' digit)* |
||||
exp <- [eE] [\-+]? digit (digit / '_' digit)* |
||||
|
||||
string <- ( |
||||
mlLiteralString |
||||
/ literalString |
||||
/ mlBasicString |
||||
/ basicString |
||||
) |
||||
|
||||
basicString <- <'"' basicChar* '"'> { p.SetBasicString(p.buffer, begin, end) } |
||||
|
||||
basicChar <- basicUnescaped / escaped |
||||
escaped <- escape ([btnfr"/\\] / 'u' hexQuad / 'U' hexQuad hexQuad) |
||||
|
||||
basicUnescaped <- [ -!#-\[\]-\0x10FFFF] |
||||
|
||||
escape <- '\\' |
||||
|
||||
mlBasicString <- '"""' mlBasicBody '"""' { p.SetMultilineString() } |
||||
|
||||
mlBasicBody <- ( |
||||
<basicChar / newline> { p.AddMultilineBasicBody(p.buffer, begin, end) } |
||||
/ escape newline wsnl |
||||
)* |
||||
|
||||
literalString <- "'" <literalChar*> "'" { p.SetLiteralString(p.buffer, begin, end) } |
||||
|
||||
literalChar <- [\t -&(-\0x10FFFF] |
||||
|
||||
mlLiteralString <- "'''" <mlLiteralBody> "'''" { p.SetMultilineLiteralString(p.buffer, begin, end) } |
||||
|
||||
mlLiteralBody <- (!"'''" (mlLiteralChar / newline))* |
||||
|
||||
mlLiteralChar <- [\t -\0x10FFFF] |
||||
|
||||
hexdigit <- [0-9A-Fa-f] |
||||
hexQuad <- hexdigit hexdigit hexdigit hexdigit |
||||
|
||||
boolean <- 'true' / 'false' |
||||
|
||||
dateFullYear <- digitQuad |
||||
dateMonth <- digitDual |
||||
dateMDay <- digitDual |
||||
timeHour <- digitDual |
||||
timeMinute <- digitDual |
||||
timeSecond <- digitDual |
||||
timeSecfrac <- '.' digit+ |
||||
timeNumoffset <- [\-+] timeHour ':' timeMinute |
||||
timeOffset <- 'Z' / timeNumoffset |
||||
partialTime <- timeHour ':' timeMinute ':' timeSecond timeSecfrac? |
||||
fullDate <- dateFullYear '-' dateMonth '-' dateMDay |
||||
fullTime <- partialTime timeOffset |
||||
datetime <- (fullDate ('T' fullTime)?) / partialTime |
||||
|
||||
digit <- [0-9] |
||||
digitDual <- digit digit |
||||
digitQuad <- digitDual digitDual |
||||
|
||||
array <- ( |
||||
'[' { p.StartArray() } |
||||
wsnl arrayValues? wsnl |
||||
']' |
||||
) |
||||
|
||||
arrayValues <- ( |
||||
val { p.AddArrayVal() } |
||||
( |
||||
wsnl comment? |
||||
wsnl arraySep |
||||
wsnl comment? |
||||
wsnl val { p.AddArrayVal() } |
||||
)* |
||||
wsnl arraySep? |
||||
wsnl comment? |
||||
) |
||||
|
||||
arraySep <- ',' |
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,65 @@ |
||||
package toml |
||||
|
||||
import ( |
||||
"fmt" |
||||
"reflect" |
||||
"strings" |
||||
) |
||||
|
||||
const fieldTagName = "toml" |
||||
|
||||
// fieldCache maps normalized field names to their position in a struct.
|
||||
type fieldCache struct { |
||||
named map[string]fieldInfo // fields with an explicit name in tag
|
||||
auto map[string]fieldInfo // fields with auto-assigned normalized names
|
||||
} |
||||
|
||||
type fieldInfo struct { |
||||
index []int |
||||
name string |
||||
ignored bool |
||||
} |
||||
|
||||
func makeFieldCache(cfg *Config, rt reflect.Type) fieldCache { |
||||
named, auto := make(map[string]fieldInfo), make(map[string]fieldInfo) |
||||
for i := 0; i < rt.NumField(); i++ { |
||||
ft := rt.Field(i) |
||||
// skip unexported fields
|
||||
if ft.PkgPath != "" && !ft.Anonymous { |
||||
continue |
||||
} |
||||
col, _ := extractTag(ft.Tag.Get(fieldTagName)) |
||||
info := fieldInfo{index: ft.Index, name: ft.Name, ignored: col == "-"} |
||||
if col == "" || col == "-" { |
||||
auto[cfg.NormFieldName(rt, ft.Name)] = info |
||||
} else { |
||||
named[col] = info |
||||
} |
||||
} |
||||
return fieldCache{named, auto} |
||||
} |
||||
|
||||
func (fc fieldCache) findField(cfg *Config, rv reflect.Value, name string) (reflect.Value, string, error) { |
||||
info, found := fc.named[name] |
||||
if !found { |
||||
info, found = fc.auto[cfg.NormFieldName(rv.Type(), name)] |
||||
} |
||||
if !found { |
||||
if cfg.MissingField == nil { |
||||
return reflect.Value{}, "", fmt.Errorf("field corresponding to `%s' is not defined in %v", name, rv.Type()) |
||||
} else { |
||||
return reflect.Value{}, "", cfg.MissingField(rv.Type(), name) |
||||
} |
||||
} else if info.ignored { |
||||
return reflect.Value{}, "", fmt.Errorf("field corresponding to `%s' in %v cannot be set through TOML", name, rv.Type()) |
||||
} |
||||
return rv.FieldByIndex(info.index), info.name, nil |
||||
} |
||||
|
||||
func extractTag(tag string) (col, rest string) { |
||||
tags := strings.SplitN(tag, ",", 2) |
||||
if len(tags) == 2 { |
||||
return strings.TrimSpace(tags[0]), strings.TrimSpace(tags[1]) |
||||
} |
||||
return strings.TrimSpace(tags[0]), "" |
||||
} |
||||
Loading…
Reference in new issue