https://github.com/BurntSushi/toml

Name	Email	Commits
Martin Tournoij	m**n@a**t	145
Andrew Gallant	j**m@g**m	121
Caleb Spare	c**e@g**m	38
Quinn Slack	q**k@q**m	20
kkHAIKE	k**e@g**m	7
Rafal Jeczalik	r**k@g**m	5
JC	s**e@g**m	3
Martin Lindhe	m**t@u**e	3
spf13	s**a@g**m	3
ttacon	t**n@g**m	3
Bjørn Erik Pedersen	b**n@g**m	2
Austin Ziegler	a**n@z**a	2
Anthony Fok	f**a@d**g	2
Brandon Buck	l**l@g**m	2
Brian Starkey	s**y@g**m	2
Bryan Matsuo	b****m	2
Dato Simó	d**o@n**s	2
Nathan Youngman	g**t@n**m	2
Seth W. Klein	sk@s****t	2
Shengjing Zhu	z**j@d**g	2
Dimitri Tcaciuc	d****c	1
Jose Diaz-Gonzalez	e**l@j**m	1
y-yagi	y**a@g**m	1
Adam Ochonicki	a**i@a**m	1
Arran Walker	a**r@f**g	1
Arran Walker	g**b@f**g	1
Baiju Muthukadan	b**l@g**m	1
Blallo	b**o@a**g	1
Denis Gladkikh	d**s@g**l	1
Greg Weber	g**g@g**o	1
and 26 more...

go: github.com/BurntSushi/toml

Package toml implements decoding and encoding of TOML files. This package supports TOML v1.0.0, as specified at https://toml.io The github.com/BurntSushi/toml/cmd/tomlv package implements a TOML validator, and can be used to verify if TOML document is valid. It can also be used to print the type of each key. Example StrictDecoding shows how to detect if there are keys in the TOML document that weren't decoded into the value given. This is useful for returning an error to the user if they've included extraneous fields in their configuration. Example UnmarshalTOML shows how to implement a struct type that knows how to unmarshal itself. The struct must take full responsibility for mapping the values passed into the struct. The method may be used with interfaces in a struct in cases where the actual type is not known until the data is examined. Example Unmarshaler shows how to decode TOML strings into your own custom data type.

Homepage: https://github.com/BurntSushi/toml
Documentation: https://pkg.go.dev/github.com/BurntSushi/toml#section-documentation
Licenses: MIT
Latest release: v1.3.2 (published over 1 year ago)
Last Synced: 2024-11-11T01:19:26.782Z (about 1 month ago)
Versions: 14
Dependent Packages: 27,921
Dependent Repositories: 185,064
Docker Downloads: 26,529,519,479
Rankings:
- Dependent repos count: 0.002%
- Dependent packages count: 0.008%
- Docker downloads count: 0.011%
- Average: 0.457%
- Stargazers count: 1.029%
- Forks count: 1.233%

go: github.com/burntsushi/toml

Package toml provides facilities for decoding and encoding TOML configuration files via reflection. There is also support for delaying decoding with the Primitive type, and querying the set of keys in a TOML document with the MetaData type. The specification implemented: https://github.com/toml-lang/toml The sub-command github.com/BurntSushi/toml/cmd/tomlv can be used to verify whether a file is a valid TOML document. It can also be used to print the type of each key in a TOML document. There are two important types of tests used for this package. The first is contained inside '*_test.go' files and uses the standard Go unit testing framework. These tests are primarily devoted to holistically testing the decoder and encoder. The second type of testing is used to verify the implementation's adherence to the TOML specification. These tests have been factored into their own project: https://github.com/BurntSushi/toml-test The reason the tests are in a separate project is so that they can be used by any implementation of TOML. Namely, it is language agnostic. Example StrictDecoding shows how to detect whether there are keys in the TOML document that weren't decoded into the value given. This is useful for returning an error to the user if they've included extraneous fields in their configuration. Example UnmarshalTOML shows how to implement a struct type that knows how to unmarshal itself. The struct must take full responsibility for mapping the values passed into the struct. The method may be used with interfaces in a struct in cases where the actual type is not known until the data is examined. Example Unmarshaler shows how to decode TOML strings into your own custom data type.

Homepage: https://github.com/burntsushi/toml
Documentation: https://pkg.go.dev/github.com/burntsushi/toml#section-documentation
Licenses: MIT
Latest release: v1.3.2 (published over 1 year ago)
Last Synced: 2024-11-11T01:19:25.276Z (about 1 month ago)
Versions: 14
Dependent Packages: 20
Dependent Repositories: 20
Docker Downloads: 3,342,479,602
Rankings:
- Docker downloads count: 0.456%
- Average: 0.989%
- Dependent packages count: 0.998%
- Stargazers count: 1.029%
- Dependent repos count: 1.229%
- Forks count: 1.233%

go: github.com/BuRNTsuShi/toml

Package toml provides facilities for decoding and encoding TOML configuration files via reflection. There is also support for delaying decoding with the Primitive type, and querying the set of keys in a TOML document with the MetaData type. The specification implemented: https://github.com/toml-lang/toml The sub-command github.com/BurntSushi/toml/cmd/tomlv can be used to verify whether a file is a valid TOML document. It can also be used to print the type of each key in a TOML document. There are two important types of tests used for this package. The first is contained inside '*_test.go' files and uses the standard Go unit testing framework. These tests are primarily devoted to holistically testing the decoder and encoder. The second type of testing is used to verify the implementation's adherence to the TOML specification. These tests have been factored into their own project: https://github.com/BurntSushi/toml-test The reason the tests are in a separate project is so that they can be used by any implementation of TOML. Namely, it is language agnostic. Example StrictDecoding shows how to detect whether there are keys in the TOML document that weren't decoded into the value given. This is useful for returning an error to the user if they've included extraneous fields in their configuration. Example UnmarshalTOML shows how to implement a struct type that knows how to unmarshal itself. The struct must take full responsibility for mapping the values passed into the struct. The method may be used with interfaces in a struct in cases where the actual type is not known until the data is examined. Example Unmarshaler shows how to decode TOML strings into your own custom data type.

Homepage: https://github.com/BuRNTsuShi/toml
Documentation: https://pkg.go.dev/github.com/BuRNTsuShi/toml#section-documentation
Licenses: MIT
Latest release: v1.3.2 (published over 1 year ago)
Last Synced: 2024-11-11T01:19:39.860Z (about 1 month ago)
Versions: 14
Dependent Packages: 0
Dependent Repositories: 0
Rankings:
- Stargazers count: 0.634%
- Forks count: 0.776%
- Average: 4.439%
- Dependent packages count: 6.999%
- Dependent repos count: 9.346%

go: github.com/BURNTSUSHI/TOML

Package toml provides facilities for decoding and encoding TOML configuration files via reflection. There is also support for delaying decoding with the Primitive type, and querying the set of keys in a TOML document with the MetaData type. The specification implemented: https://github.com/toml-lang/toml The sub-command github.com/BurntSushi/toml/cmd/tomlv can be used to verify whether a file is a valid TOML document. It can also be used to print the type of each key in a TOML document. There are two important types of tests used for this package. The first is contained inside '*_test.go' files and uses the standard Go unit testing framework. These tests are primarily devoted to holistically testing the decoder and encoder. The second type of testing is used to verify the implementation's adherence to the TOML specification. These tests have been factored into their own project: https://github.com/BurntSushi/toml-test The reason the tests are in a separate project is so that they can be used by any implementation of TOML. Namely, it is language agnostic. Example StrictDecoding shows how to detect whether there are keys in the TOML document that weren't decoded into the value given. This is useful for returning an error to the user if they've included extraneous fields in their configuration. Example UnmarshalTOML shows how to implement a struct type that knows how to unmarshal itself. The struct must take full responsibility for mapping the values passed into the struct. The method may be used with interfaces in a struct in cases where the actual type is not known until the data is examined. Example Unmarshaler shows how to decode TOML strings into your own custom data type.

Homepage: https://github.com/BURNTSUSHI/TOML
Documentation: https://pkg.go.dev/github.com/BURNTSUSHI/TOML#section-documentation
Licenses: MIT
Latest release: v1.3.2 (published over 1 year ago)
Last Synced: 2024-11-11T01:19:39.587Z (about 1 month ago)
Versions: 14
Dependent Packages: 0
Dependent Repositories: 0
Rankings:
- Stargazers count: 0.634%
- Forks count: 0.776%
- Average: 4.439%
- Dependent packages count: 6.999%
- Dependent repos count: 9.346%

go: github.com/BurntSushi/Toml

Package toml provides facilities for decoding and encoding TOML configuration files via reflection. There is also support for delaying decoding with the Primitive type, and querying the set of keys in a TOML document with the MetaData type. The specification implemented: https://github.com/toml-lang/toml The sub-command github.com/BurntSushi/toml/cmd/tomlv can be used to verify whether a file is a valid TOML document. It can also be used to print the type of each key in a TOML document. There are two important types of tests used for this package. The first is contained inside '*_test.go' files and uses the standard Go unit testing framework. These tests are primarily devoted to holistically testing the decoder and encoder. The second type of testing is used to verify the implementation's adherence to the TOML specification. These tests have been factored into their own project: https://github.com/BurntSushi/toml-test The reason the tests are in a separate project is so that they can be used by any implementation of TOML. Namely, it is language agnostic. Example StrictDecoding shows how to detect whether there are keys in the TOML document that weren't decoded into the value given. This is useful for returning an error to the user if they've included extraneous fields in their configuration. Example UnmarshalTOML shows how to implement a struct type that knows how to unmarshal itself. The struct must take full responsibility for mapping the values passed into the struct. The method may be used with interfaces in a struct in cases where the actual type is not known until the data is examined. Example Unmarshaler shows how to decode TOML strings into your own custom data type.

Homepage: https://github.com/BurntSushi/Toml
Documentation: https://pkg.go.dev/github.com/BurntSushi/Toml#section-documentation
Licenses: MIT
Latest release: v1.3.2 (published over 1 year ago)
Last Synced: 2024-11-11T01:19:24.413Z (about 1 month ago)
Versions: 14
Dependent Packages: 0
Dependent Repositories: 0
Rankings:
- Stargazers count: 0.634%
- Forks count: 0.776%
- Average: 4.439%
- Dependent packages count: 6.999%
- Dependent repos count: 9.346%

go: github.com/BuRntSushi/toml

Package toml provides facilities for decoding and encoding TOML configuration files via reflection. There is also support for delaying decoding with the Primitive type, and querying the set of keys in a TOML document with the MetaData type. The specification implemented: https://github.com/toml-lang/toml The sub-command github.com/BurntSushi/toml/cmd/tomlv can be used to verify whether a file is a valid TOML document. It can also be used to print the type of each key in a TOML document. There are two important types of tests used for this package. The first is contained inside '*_test.go' files and uses the standard Go unit testing framework. These tests are primarily devoted to holistically testing the decoder and encoder. The second type of testing is used to verify the implementation's adherence to the TOML specification. These tests have been factored into their own project: https://github.com/BurntSushi/toml-test The reason the tests are in a separate project is so that they can be used by any implementation of TOML. Namely, it is language agnostic. Example StrictDecoding shows how to detect whether there are keys in the TOML document that weren't decoded into the value given. This is useful for returning an error to the user if they've included extraneous fields in their configuration. Example UnmarshalTOML shows how to implement a struct type that knows how to unmarshal itself. The struct must take full responsibility for mapping the values passed into the struct. The method may be used with interfaces in a struct in cases where the actual type is not known until the data is examined. Example Unmarshaler shows how to decode TOML strings into your own custom data type.

Homepage: https://github.com/BuRntSushi/toml
Documentation: https://pkg.go.dev/github.com/BuRntSushi/toml#section-documentation
Licenses: MIT
Latest release: v1.3.2 (published over 1 year ago)
Last Synced: 2024-11-11T01:19:27.976Z (about 1 month ago)
Versions: 14
Dependent Packages: 0
Dependent Repositories: 0
Rankings:
- Stargazers count: 0.634%
- Forks count: 0.776%
- Average: 4.439%
- Dependent packages count: 6.999%
- Dependent repos count: 9.346%

go: github.com/burntSushi/toml

Package toml provides facilities for decoding and encoding TOML configuration files via reflection. There is also support for delaying decoding with the Primitive type, and querying the set of keys in a TOML document with the MetaData type. The specification implemented: https://github.com/toml-lang/toml The sub-command github.com/BurntSushi/toml/cmd/tomlv can be used to verify whether a file is a valid TOML document. It can also be used to print the type of each key in a TOML document. There are two important types of tests used for this package. The first is contained inside '*_test.go' files and uses the standard Go unit testing framework. These tests are primarily devoted to holistically testing the decoder and encoder. The second type of testing is used to verify the implementation's adherence to the TOML specification. These tests have been factored into their own project: https://github.com/BurntSushi/toml-test The reason the tests are in a separate project is so that they can be used by any implementation of TOML. Namely, it is language agnostic. Example StrictDecoding shows how to detect whether there are keys in the TOML document that weren't decoded into the value given. This is useful for returning an error to the user if they've included extraneous fields in their configuration. Example UnmarshalTOML shows how to implement a struct type that knows how to unmarshal itself. The struct must take full responsibility for mapping the values passed into the struct. The method may be used with interfaces in a struct in cases where the actual type is not known until the data is examined. Example Unmarshaler shows how to decode TOML strings into your own custom data type.

Homepage: https://github.com/burntSushi/toml
Documentation: https://pkg.go.dev/github.com/burntSushi/toml#section-documentation
Licenses: MIT
Latest release: v1.3.2 (published over 1 year ago)
Last Synced: 2024-11-11T01:19:28.839Z (about 1 month ago)
Versions: 14
Dependent Packages: 1
Dependent Repositories: 0
Rankings:
- Stargazers count: 0.634%
- Forks count: 0.776%
- Average: 4.439%
- Dependent packages count: 6.999%
- Dependent repos count: 9.346%

go: github.com/bUrntsUshi/toml

Package toml provides facilities for decoding and encoding TOML configuration files via reflection. There is also support for delaying decoding with the Primitive type, and querying the set of keys in a TOML document with the MetaData type. The specification implemented: https://github.com/toml-lang/toml The sub-command github.com/BurntSushi/toml/cmd/tomlv can be used to verify whether a file is a valid TOML document. It can also be used to print the type of each key in a TOML document. There are two important types of tests used for this package. The first is contained inside '*_test.go' files and uses the standard Go unit testing framework. These tests are primarily devoted to holistically testing the decoder and encoder. The second type of testing is used to verify the implementation's adherence to the TOML specification. These tests have been factored into their own project: https://github.com/BurntSushi/toml-test The reason the tests are in a separate project is so that they can be used by any implementation of TOML. Namely, it is language agnostic. Example StrictDecoding shows how to detect whether there are keys in the TOML document that weren't decoded into the value given. This is useful for returning an error to the user if they've included extraneous fields in their configuration. Example UnmarshalTOML shows how to implement a struct type that knows how to unmarshal itself. The struct must take full responsibility for mapping the values passed into the struct. The method may be used with interfaces in a struct in cases where the actual type is not known until the data is examined. Example Unmarshaler shows how to decode TOML strings into your own custom data type.

Homepage: https://github.com/bUrntsUshi/toml
Documentation: https://pkg.go.dev/github.com/bUrntsUshi/toml#section-documentation
Licenses: MIT
Latest release: v1.3.2 (published over 1 year ago)
Last Synced: 2024-11-11T01:19:21.559Z (about 1 month ago)
Versions: 14
Dependent Packages: 0
Dependent Repositories: 0
Rankings:
- Stargazers count: 0.634%
- Forks count: 0.776%
- Average: 4.439%
- Dependent packages count: 6.999%
- Dependent repos count: 9.346%

go: github.com/Burntsushi/toml

Package toml provides facilities for decoding and encoding TOML configuration files via reflection. There is also support for delaying decoding with the Primitive type, and querying the set of keys in a TOML document with the MetaData type. The specification implemented: https://github.com/toml-lang/toml The sub-command github.com/BurntSushi/toml/cmd/tomlv can be used to verify whether a file is a valid TOML document. It can also be used to print the type of each key in a TOML document. There are two important types of tests used for this package. The first is contained inside '*_test.go' files and uses the standard Go unit testing framework. These tests are primarily devoted to holistically testing the decoder and encoder. The second type of testing is used to verify the implementation's adherence to the TOML specification. These tests have been factored into their own project: https://github.com/BurntSushi/toml-test The reason the tests are in a separate project is so that they can be used by any implementation of TOML. Namely, it is language agnostic. Example StrictDecoding shows how to detect whether there are keys in the TOML document that weren't decoded into the value given. This is useful for returning an error to the user if they've included extraneous fields in their configuration. Example UnmarshalTOML shows how to implement a struct type that knows how to unmarshal itself. The struct must take full responsibility for mapping the values passed into the struct. The method may be used with interfaces in a struct in cases where the actual type is not known until the data is examined. Example Unmarshaler shows how to decode TOML strings into your own custom data type.

Homepage: https://github.com/Burntsushi/toml
Documentation: https://pkg.go.dev/github.com/Burntsushi/toml#section-documentation
Licenses: MIT
Latest release: v1.3.2 (published over 1 year ago)
Last Synced: 2024-11-11T01:19:35.289Z (about 1 month ago)
Versions: 14
Dependent Packages: 0
Dependent Repositories: 0
Rankings:
- Stargazers count: 0.635%
- Forks count: 0.776%
- Average: 4.439%
- Dependent packages count: 6.999%
- Dependent repos count: 9.346%

go: github.com/BurnTSushi/toml

Package toml provides facilities for decoding and encoding TOML configuration files via reflection. There is also support for delaying decoding with the Primitive type, and querying the set of keys in a TOML document with the MetaData type. The specification implemented: https://github.com/toml-lang/toml The sub-command github.com/BurntSushi/toml/cmd/tomlv can be used to verify whether a file is a valid TOML document. It can also be used to print the type of each key in a TOML document. There are two important types of tests used for this package. The first is contained inside '*_test.go' files and uses the standard Go unit testing framework. These tests are primarily devoted to holistically testing the decoder and encoder. The second type of testing is used to verify the implementation's adherence to the TOML specification. These tests have been factored into their own project: https://github.com/BurntSushi/toml-test The reason the tests are in a separate project is so that they can be used by any implementation of TOML. Namely, it is language agnostic. Example StrictDecoding shows how to detect whether there are keys in the TOML document that weren't decoded into the value given. This is useful for returning an error to the user if they've included extraneous fields in their configuration. Example UnmarshalTOML shows how to implement a struct type that knows how to unmarshal itself. The struct must take full responsibility for mapping the values passed into the struct. The method may be used with interfaces in a struct in cases where the actual type is not known until the data is examined. Example Unmarshaler shows how to decode TOML strings into your own custom data type.

Homepage: https://github.com/BurnTSushi/toml
Documentation: https://pkg.go.dev/github.com/BurnTSushi/toml#section-documentation
Licenses: MIT
Latest release: v1.3.2 (published over 1 year ago)
Last Synced: 2024-11-11T01:19:37.734Z (about 1 month ago)
Versions: 14
Dependent Packages: 0
Dependent Repositories: 0
Rankings:
- Forks count: 0.774%
- Stargazers count: 0.858%
- Average: 4.494%
- Dependent packages count: 6.999%
- Dependent repos count: 9.346%

go: github.com/BurntSushi/tomL

Package toml provides facilities for decoding and encoding TOML configuration files via reflection. There is also support for delaying decoding with the Primitive type, and querying the set of keys in a TOML document with the MetaData type. The specification implemented: https://github.com/toml-lang/toml The sub-command github.com/BurntSushi/toml/cmd/tomlv can be used to verify whether a file is a valid TOML document. It can also be used to print the type of each key in a TOML document. There are two important types of tests used for this package. The first is contained inside '*_test.go' files and uses the standard Go unit testing framework. These tests are primarily devoted to holistically testing the decoder and encoder. The second type of testing is used to verify the implementation's adherence to the TOML specification. These tests have been factored into their own project: https://github.com/BurntSushi/toml-test The reason the tests are in a separate project is so that they can be used by any implementation of TOML. Namely, it is language agnostic. Example StrictDecoding shows how to detect whether there are keys in the TOML document that weren't decoded into the value given. This is useful for returning an error to the user if they've included extraneous fields in their configuration. Example UnmarshalTOML shows how to implement a struct type that knows how to unmarshal itself. The struct must take full responsibility for mapping the values passed into the struct. The method may be used with interfaces in a struct in cases where the actual type is not known until the data is examined. Example Unmarshaler shows how to decode TOML strings into your own custom data type.

Homepage: https://github.com/BurntSushi/tomL
Documentation: https://pkg.go.dev/github.com/BurntSushi/tomL#section-documentation
Licenses: MIT
Latest release: v1.3.2 (published over 1 year ago)
Last Synced: 2024-11-11T01:19:19.920Z (about 1 month ago)
Versions: 14
Dependent Packages: 0
Dependent Repositories: 0
Rankings:
- Stargazers count: 1.021%
- Forks count: 1.214%
- Average: 4.901%
- Dependent packages count: 8.074%
- Dependent repos count: 9.294%

go: github.com/BurntSuShI/toml

Package toml provides facilities for decoding and encoding TOML configuration files via reflection. There is also support for delaying decoding with the Primitive type, and querying the set of keys in a TOML document with the MetaData type. The specification implemented: https://github.com/toml-lang/toml The sub-command github.com/BurntSushi/toml/cmd/tomlv can be used to verify whether a file is a valid TOML document. It can also be used to print the type of each key in a TOML document. There are two important types of tests used for this package. The first is contained inside '*_test.go' files and uses the standard Go unit testing framework. These tests are primarily devoted to holistically testing the decoder and encoder. The second type of testing is used to verify the implementation's adherence to the TOML specification. These tests have been factored into their own project: https://github.com/BurntSushi/toml-test The reason the tests are in a separate project is so that they can be used by any implementation of TOML. Namely, it is language agnostic. Example StrictDecoding shows how to detect whether there are keys in the TOML document that weren't decoded into the value given. This is useful for returning an error to the user if they've included extraneous fields in their configuration. Example UnmarshalTOML shows how to implement a struct type that knows how to unmarshal itself. The struct must take full responsibility for mapping the values passed into the struct. The method may be used with interfaces in a struct in cases where the actual type is not known until the data is examined. Example Unmarshaler shows how to decode TOML strings into your own custom data type.

Homepage: https://github.com/BurntSuShI/toml
Documentation: https://pkg.go.dev/github.com/BurntSuShI/toml#section-documentation
Licenses: MIT
Latest release: v1.3.2 (published over 1 year ago)
Last Synced: 2024-11-11T01:19:33.459Z (about 1 month ago)
Versions: 14
Dependent Packages: 0
Dependent Repositories: 0
Rankings:
- Stargazers count: 1.021%
- Forks count: 1.215%
- Average: 4.901%
- Dependent packages count: 8.083%
- Dependent repos count: 9.283%

go: github.com/BurntSushI/toml

Package toml provides facilities for decoding and encoding TOML configuration files via reflection. There is also support for delaying decoding with the Primitive type, and querying the set of keys in a TOML document with the MetaData type. The specification implemented: https://github.com/toml-lang/toml The sub-command github.com/BurntSushi/toml/cmd/tomlv can be used to verify whether a file is a valid TOML document. It can also be used to print the type of each key in a TOML document. There are two important types of tests used for this package. The first is contained inside '*_test.go' files and uses the standard Go unit testing framework. These tests are primarily devoted to holistically testing the decoder and encoder. The second type of testing is used to verify the implementation's adherence to the TOML specification. These tests have been factored into their own project: https://github.com/BurntSushi/toml-test The reason the tests are in a separate project is so that they can be used by any implementation of TOML. Namely, it is language agnostic. Example StrictDecoding shows how to detect whether there are keys in the TOML document that weren't decoded into the value given. This is useful for returning an error to the user if they've included extraneous fields in their configuration. Example UnmarshalTOML shows how to implement a struct type that knows how to unmarshal itself. The struct must take full responsibility for mapping the values passed into the struct. The method may be used with interfaces in a struct in cases where the actual type is not known until the data is examined. Example Unmarshaler shows how to decode TOML strings into your own custom data type.

Homepage: https://github.com/BurntSushI/toml
Documentation: https://pkg.go.dev/github.com/BurntSushI/toml#section-documentation
Licenses: MIT
Latest release: v1.3.2 (published over 1 year ago)
Last Synced: 2024-11-11T01:19:38.513Z (about 1 month ago)
Versions: 14
Dependent Packages: 0
Dependent Repositories: 0
Rankings:
- Stargazers count: 1.021%
- Forks count: 1.215%
- Average: 4.901%
- Dependent packages count: 8.083%
- Dependent repos count: 9.283%

go: github.com/BurnTSusHi/toml

Package toml provides facilities for decoding and encoding TOML configuration files via reflection. There is also support for delaying decoding with the Primitive type, and querying the set of keys in a TOML document with the MetaData type. The specification implemented: https://github.com/toml-lang/toml The sub-command github.com/BurntSushi/toml/cmd/tomlv can be used to verify whether a file is a valid TOML document. It can also be used to print the type of each key in a TOML document. There are two important types of tests used for this package. The first is contained inside '*_test.go' files and uses the standard Go unit testing framework. These tests are primarily devoted to holistically testing the decoder and encoder. The second type of testing is used to verify the implementation's adherence to the TOML specification. These tests have been factored into their own project: https://github.com/BurntSushi/toml-test The reason the tests are in a separate project is so that they can be used by any implementation of TOML. Namely, it is language agnostic. Example StrictDecoding shows how to detect whether there are keys in the TOML document that weren't decoded into the value given. This is useful for returning an error to the user if they've included extraneous fields in their configuration. Example UnmarshalTOML shows how to implement a struct type that knows how to unmarshal itself. The struct must take full responsibility for mapping the values passed into the struct. The method may be used with interfaces in a struct in cases where the actual type is not known until the data is examined. Example Unmarshaler shows how to decode TOML strings into your own custom data type.

Homepage: https://github.com/BurnTSusHi/toml
Documentation: https://pkg.go.dev/github.com/BurnTSusHi/toml#section-documentation
Licenses: MIT
Latest release: v1.3.2 (published over 1 year ago)
Last Synced: 2024-11-11T01:19:38.205Z (about 1 month ago)
Versions: 14
Dependent Packages: 0
Dependent Repositories: 0
Rankings:
- Stargazers count: 1.019%
- Forks count: 1.226%
- Average: 5.428%
- Dependent packages count: 8.899%
- Dependent repos count: 10.567%

go: github.com/BurNTSusHI/toml

Package toml provides facilities for decoding and encoding TOML configuration files via reflection. There is also support for delaying decoding with the Primitive type, and querying the set of keys in a TOML document with the MetaData type. The specification implemented: https://github.com/toml-lang/toml The sub-command github.com/BurntSushi/toml/cmd/tomlv can be used to verify whether a file is a valid TOML document. It can also be used to print the type of each key in a TOML document. There are two important types of tests used for this package. The first is contained inside '*_test.go' files and uses the standard Go unit testing framework. These tests are primarily devoted to holistically testing the decoder and encoder. The second type of testing is used to verify the implementation's adherence to the TOML specification. These tests have been factored into their own project: https://github.com/BurntSushi/toml-test The reason the tests are in a separate project is so that they can be used by any implementation of TOML. Namely, it is language agnostic. Example StrictDecoding shows how to detect whether there are keys in the TOML document that weren't decoded into the value given. This is useful for returning an error to the user if they've included extraneous fields in their configuration. Example UnmarshalTOML shows how to implement a struct type that knows how to unmarshal itself. The struct must take full responsibility for mapping the values passed into the struct. The method may be used with interfaces in a struct in cases where the actual type is not known until the data is examined. Example Unmarshaler shows how to decode TOML strings into your own custom data type.

Homepage: https://github.com/BurNTSusHI/toml
Documentation: https://pkg.go.dev/github.com/BurNTSusHI/toml#section-documentation
Licenses: MIT
Latest release: v1.3.2 (published over 1 year ago)
Last Synced: 2024-11-11T01:19:34.524Z (about 1 month ago)
Versions: 14
Dependent Packages: 0
Dependent Repositories: 0
Rankings:
- Stargazers count: 1.015%
- Forks count: 1.236%
- Average: 5.485%
- Dependent packages count: 8.978%
- Dependent repos count: 10.713%

go: github.com/BUrntSushi/toml

Package toml provides facilities for decoding and encoding TOML configuration files via reflection. There is also support for delaying decoding with the Primitive type, and querying the set of keys in a TOML document with the MetaData type. The specification implemented: https://github.com/toml-lang/toml The sub-command github.com/BurntSushi/toml/cmd/tomlv can be used to verify whether a file is a valid TOML document. It can also be used to print the type of each key in a TOML document. There are two important types of tests used for this package. The first is contained inside '*_test.go' files and uses the standard Go unit testing framework. These tests are primarily devoted to holistically testing the decoder and encoder. The second type of testing is used to verify the implementation's adherence to the TOML specification. These tests have been factored into their own project: https://github.com/BurntSushi/toml-test The reason the tests are in a separate project is so that they can be used by any implementation of TOML. Namely, it is language agnostic. Example StrictDecoding shows how to detect whether there are keys in the TOML document that weren't decoded into the value given. This is useful for returning an error to the user if they've included extraneous fields in their configuration. Example UnmarshalTOML shows how to implement a struct type that knows how to unmarshal itself. The struct must take full responsibility for mapping the values passed into the struct. The method may be used with interfaces in a struct in cases where the actual type is not known until the data is examined. Example Unmarshaler shows how to decode TOML strings into your own custom data type.

Homepage: https://github.com/BUrntSushi/toml
Documentation: https://pkg.go.dev/github.com/BUrntSushi/toml#section-documentation
Licenses: MIT
Latest release: v1.3.2 (published over 1 year ago)
Last Synced: 2024-11-11T01:19:29.649Z (about 1 month ago)
Versions: 14
Dependent Packages: 0
Dependent Repositories: 0
Rankings:
- Dependent packages count: 6.999%
- Average: 8.173%
- Dependent repos count: 9.346%

go: github.com/BurntSuShi/toml

Package toml provides facilities for decoding and encoding TOML configuration files via reflection. There is also support for delaying decoding with the Primitive type, and querying the set of keys in a TOML document with the MetaData type. The specification implemented: https://github.com/toml-lang/toml The sub-command github.com/BurntSushi/toml/cmd/tomlv can be used to verify whether a file is a valid TOML document. It can also be used to print the type of each key in a TOML document. There are two important types of tests used for this package. The first is contained inside '*_test.go' files and uses the standard Go unit testing framework. These tests are primarily devoted to holistically testing the decoder and encoder. The second type of testing is used to verify the implementation's adherence to the TOML specification. These tests have been factored into their own project: https://github.com/BurntSushi/toml-test The reason the tests are in a separate project is so that they can be used by any implementation of TOML. Namely, it is language agnostic. Example StrictDecoding shows how to detect whether there are keys in the TOML document that weren't decoded into the value given. This is useful for returning an error to the user if they've included extraneous fields in their configuration. Example UnmarshalTOML shows how to implement a struct type that knows how to unmarshal itself. The struct must take full responsibility for mapping the values passed into the struct. The method may be used with interfaces in a struct in cases where the actual type is not known until the data is examined. Example Unmarshaler shows how to decode TOML strings into your own custom data type.

Homepage: https://github.com/BurntSuShi/toml
Documentation: https://pkg.go.dev/github.com/BurntSuShi/toml#section-documentation
Licenses: MIT
Latest release: v1.3.2 (published over 1 year ago)
Last Synced: 2024-11-11T01:19:31.443Z (about 1 month ago)
Versions: 14
Dependent Packages: 0
Dependent Repositories: 0
Rankings:
- Dependent packages count: 6.999%
- Average: 8.173%
- Dependent repos count: 9.346%

go: github.com/BurntSUshi/toml

Package toml provides facilities for decoding and encoding TOML configuration files via reflection. There is also support for delaying decoding with the Primitive type, and querying the set of keys in a TOML document with the MetaData type. The specification implemented: https://github.com/toml-lang/toml The sub-command github.com/BurntSushi/toml/cmd/tomlv can be used to verify whether a file is a valid TOML document. It can also be used to print the type of each key in a TOML document. There are two important types of tests used for this package. The first is contained inside '*_test.go' files and uses the standard Go unit testing framework. These tests are primarily devoted to holistically testing the decoder and encoder. The second type of testing is used to verify the implementation's adherence to the TOML specification. These tests have been factored into their own project: https://github.com/BurntSushi/toml-test The reason the tests are in a separate project is so that they can be used by any implementation of TOML. Namely, it is language agnostic. Example StrictDecoding shows how to detect whether there are keys in the TOML document that weren't decoded into the value given. This is useful for returning an error to the user if they've included extraneous fields in their configuration. Example UnmarshalTOML shows how to implement a struct type that knows how to unmarshal itself. The struct must take full responsibility for mapping the values passed into the struct. The method may be used with interfaces in a struct in cases where the actual type is not known until the data is examined. Example Unmarshaler shows how to decode TOML strings into your own custom data type.

Homepage: https://github.com/BurntSUshi/toml
Documentation: https://pkg.go.dev/github.com/BurntSUshi/toml#section-documentation
Licenses: MIT
Latest release: v1.3.2 (published over 1 year ago)
Last Synced: 2024-11-11T01:19:36.711Z (about 1 month ago)
Versions: 14
Dependent Packages: 0
Dependent Repositories: 0
Rankings:
- Dependent packages count: 8.61%
- Average: 9.159%
- Dependent repos count: 9.709%

.github/workflows/test.yml actions

actions/checkout v3 composite
actions/setup-go v3 composite

go.mod go

testdata/Cargo.toml cargo

Ecosyste.ms: Funds