Bump gopkg.in/yaml.v2 from 2.2.3 to 2.2.4 (#309)

Bumps [gopkg.in/yaml.v2](https://github.com/go-yaml/yaml) from 2.2.3 to 2.2.4.
- [Release notes](https://github.com/go-yaml/yaml/releases)
- [Commits](https://github.com/go-yaml/yaml/compare/v2.2.3...v2.2.4)

Signed-off-by: dependabot-preview[bot] <support@dependabot.com>

.dockerignore

@@ -0,0 +1,2 @@
+cmd/tomll/tomll
+cmd/tomljson/tomljson

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,22 @@
+---
+name: Bug report
+about: Create a report to help us improve
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior. Including TOML files.
+
+**Expected behavior**
+A clear and concise description of what you expected to happen, if other than "should work".
+
+**Versions**
+ - go-toml: version (git sha)
+ - go: version
+ - operating system: e.g. macOS, Windows, Linux
+
+**Additional context**
+Add any other context about the problem here that you think may help to diagnose.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,17 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.gitignore

@@ -1 +1,5 @@
 test_program/test_program_bin
+fuzz/
+cmd/tomll/tomll
+cmd/tomljson/tomljson
+cmd/tomltestgen/tomltestgen

.travis.yml

@@ -1,23 +0,0 @@
-sudo: false
-language: go
-go:
-  - 1.7.6
-  - 1.8.3
-  - 1.9
-  - tip
-matrix:
-  allow_failures:
-    - go: tip
-  fast_finish: true
-script:
-  - if [ -n "$(go fmt ./...)" ]; then exit 1; fi
-  - ./test.sh
-  - ./benchmark.sh $TRAVIS_BRANCH https://github.com/$TRAVIS_REPO_SLUG.git
-before_install:
-  - go get github.com/axw/gocov/gocov
-  - go get github.com/mattn/goveralls
-  - if ! go get code.google.com/p/go.tools/cmd/cover; then go get golang.org/x/tools/cmd/cover; fi
-branches:
-  only: [master]
-after_success:
-  - $HOME/gopath/bin/goveralls -service=travis-ci -coverprofile=coverage.out -repotoken $COVERALLS_TOKEN

CONTRIBUTING.md

@@ -0,0 +1,132 @@
+## Contributing
+
+Thank you for your interest in go-toml! We appreciate you considering
+contributing to go-toml!
+
+The main goal is the project is to provide an easy-to-use TOML
+implementation for Go that gets the job done and gets out of your way –
+dealing with TOML is probably not the central piece of your project.
+
+As the single maintainer of go-toml, time is scarce. All help, big or
+small, is more than welcomed!
+
+### Ask questions
+
+Any question you may have, somebody else might have it too. Always feel
+free to ask them on the [issues tracker][issues-tracker].  We will try to
+answer them as clearly and quickly as possible, time permitting.
+
+Asking questions also helps us identify areas where the documentation needs
+improvement, or new features that weren't envisioned before. Sometimes, a
+seemingly innocent question leads to the fix of a bug. Don't hesitate and
+ask away!
+
+### Improve the documentation
+
+The best way to share your knowledge and experience with go-toml is to
+improve the documentation. Fix a typo, clarify an interface, add an
+example, anything goes!
+
+The documentation is present in the [README][readme] and thorough the
+source code. On release, it gets updated on [GoDoc][godoc]. To make a
+change to the documentation, create a pull request with your proposed
+changes. For simple changes like that, the easiest way to go is probably
+the "Fork this project and edit the file" button on Github, displayed at
+the top right of the file. Unless it's a trivial change (for example a
+typo), provide a little bit of context in your pull request description or
+commit message.
+
+### Report a bug
+
+Found a bug! Sorry to hear that :(. Help us and other track them down and
+fix by reporting it. [File a new bug report][bug-report] on the [issues
+tracker][issues-tracker]. The template should provide enough guidance on
+what to include. When in doubt: add more details! By reducing ambiguity and
+providing more information, it decreases back and forth and saves everyone
+time.
+
+### Code changes
+
+Want to contribute a patch? Very happy to hear that!
+
+First, some high-level rules:
+
+* A short proposal with some POC code is better than a lengthy piece of
+  text with no code. Code speaks louder than words.
+* No backward-incompatible patch will be accepted unless discussed.
+  Sometimes it's hard, and Go's lack of versioning by default does not
+  help, but we try not to break people's programs unless we absolutely have
+  to.
+* If you are writing a new feature or extending an existing one, make sure
+  to write some documentation.
+* Bug fixes need to be accompanied with regression tests.
+* New code needs to be tested.
+* Your commit messages need to explain why the change is needed, even if
+  already included in the PR description.
+
+It does sound like a lot, but those best practices are here to save time
+overall and continuously improve the quality of the project, which is
+something everyone benefits from.
+
+#### Get started
+
+The fairly standard code contribution process looks like that:
+
+1. [Fork the project][fork].
+2. Make your changes, commit on any branch you like.
+3. [Open up a pull request][pull-request]
+4. Review, potential ask for changes.
+5. Merge. You're in!
+
+Feel free to ask for help! You can create draft pull requests to gather
+some early feedback!
+
+#### Run the tests
+
+You can run tests for go-toml using Go's test tool: `go test ./...`.
+When creating a pull requests, all tests will be ran on Linux on a few Go
+versions (Travis CI), and on Windows using the latest Go version
+(AppVeyor).
+
+#### Style
+
+Try to look around and follow the same format and structure as the rest of
+the code. We enforce using `go fmt` on the whole code base.
+
+---
+
+### Maintainers-only
+
+#### Merge pull request
+
+Checklist:
+
+* Passing CI.
+* Does not introduce backward-incompatible changes (unless discussed).
+* Has relevant doc changes.
+* Has relevant unit tests.
+
+1. Merge using "squash and merge".
+2. Make sure to edit the commit message to keep all the useful information
+   nice and clean.
+3. Make sure the commit title is clear and contains the PR number (#123).
+
+#### New release
+
+1. Go to [releases][releases]. Click on "X commits to master since this
+   release".
+2. Make note of all the changes. Look for backward incompatible changes,
+   new features, and bug fixes.
+3. Pick the new version using the above and semver.
+4. Create a [new release][new-release].
+5. Follow the same format as [1.1.0][release-110].
+
+[issues-tracker]: https://github.com/pelletier/go-toml/issues
+[bug-report]: https://github.com/pelletier/go-toml/issues/new?template=bug_report.md
+[godoc]: https://godoc.org/github.com/pelletier/go-toml
+[readme]: ./README.md
+[fork]: https://help.github.com/articles/fork-a-repo
+[pull-request]: https://help.github.com/en/articles/creating-a-pull-request
+[releases]: https://github.com/pelletier/go-toml/releases
+[new-release]: https://github.com/pelletier/go-toml/releases/new
+[release-110]: https://github.com/pelletier/go-toml/releases/tag/v1.1.0

Dockerfile

@@ -0,0 +1,11 @@
+FROM golang:1.12-alpine3.9 as builder
+WORKDIR /go/src/github.com/pelletier/go-toml
+COPY . .
+ENV CGO_ENABLED=0
+ENV GOOS=linux
+RUN go install ./...
+
+FROM scratch
+COPY --from=builder /go/bin/tomll /usr/bin/tomll
+COPY --from=builder /go/bin/tomljson /usr/bin/tomljson
+COPY --from=builder /go/bin/jsontoml /usr/bin/jsontoml

PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,5 @@
+**Issue:** add link to pelletier/go-toml issue here
+
+Explanation of what this pull request does.
+
+More detailed description of the decisions being made and the reasons why (if the patch is non-trivial).

README.md

@@ -7,9 +7,10 @@ This library supports TOML version
 
 [![GoDoc](https://godoc.org/github.com/pelletier/go-toml?status.svg)](http://godoc.org/github.com/pelletier/go-toml)
 [![license](https://img.shields.io/github/license/pelletier/go-toml.svg)](https://github.com/pelletier/go-toml/blob/master/LICENSE)
-[![Build Status](https://travis-ci.org/pelletier/go-toml.svg?branch=master)](https://travis-ci.org/pelletier/go-toml)
+[![Build Status](https://dev.azure.com/pelletierthomas/go-toml-ci/_apis/build/status/pelletier.go-toml?branchName=master)](https://dev.azure.com/pelletierthomas/go-toml-ci/_build/latest?definitionId=1&branchName=master)
-[![Coverage Status](https://coveralls.io/repos/github/pelletier/go-toml/badge.svg?branch=master)](https://coveralls.io/github/pelletier/go-toml?branch=master)
+[![codecov](https://codecov.io/gh/pelletier/go-toml/branch/master/graph/badge.svg)](https://codecov.io/gh/pelletier/go-toml)
 [![Go Report Card](https://goreportcard.com/badge/github.com/pelletier/go-toml)](https://goreportcard.com/report/github.com/pelletier/go-toml)
+[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fpelletier%2Fgo-toml.svg?type=shield)](https://app.fossa.io/projects/git%2Bgithub.com%2Fpelletier%2Fgo-toml?ref=badge_shield)
 
 ## Features
 
@@ -57,9 +58,9 @@ type Config struct {
 }
 
 doc := []byte(`
-[postgres]
+[Postgres]
-user = "pelletier"
+User = "pelletier"
-password = "mypassword"`)
+Password = "mypassword"`)
 
 config := Config{}
 toml.Unmarshal(doc, &config)
@@ -98,6 +99,30 @@ Go-toml provides two handy command line tools:
     go install github.com/pelletier/go-toml/cmd/tomljson
     tomljson --help
     ```
+  
+ * `jsontoml`: Reads a JSON file and outputs a TOML representation.
+ 
+    ```
+    go install github.com/pelletier/go-toml/cmd/jsontoml
+    jsontoml --help
+    ```
+
+### Docker image
+
+Those tools are also availble as a Docker image from
+[dockerhub](https://hub.docker.com/r/pelletier/go-toml). For example, to
+use `tomljson`:
+
+```
+docker run -v $PWD:/workdir pelletier/go-toml tomljson /workdir/example.toml
+```
+
+Only master (`latest`) and tagged versions are published to dockerhub. You
+can build your own image as usual:
+
+```
+docker build -t go-toml .
+```
 
 ## Contribute
 
@@ -107,12 +132,19 @@ much appreciated!
 
 ### Run tests
 
-You have to make sure two kind of tests run:
+`go test ./...`
 
-1. The Go unit tests
+### Fuzzing
-2. The TOML examples base
 
-You can run both of them using `./test.sh`.
+The script `./fuzz.sh` is available to
+run [go-fuzz](https://github.com/dvyukov/go-fuzz) on go-toml.
+
+## Versioning
+
+Go-toml follows [Semantic Versioning](http://semver.org/). The supported version
+of [TOML](https://github.com/toml-lang/toml) is indicated at the beginning of
+this document. The last two major versions of Go are supported
+(see [Go Release Policy](https://golang.org/doc/devel/release.html#policy)).
 
 ## License
 

azure-pipelines.yml

@@ -0,0 +1,167 @@
+trigger:
+- master
+
+stages:
+- stage: fuzzit
+  displayName: "Run Fuzzit"
+  dependsOn: []
+  condition: and(succeeded(), eq(variables['Build.SourceBranchName'], 'master'))
+  jobs:
+  - job: submit
+    displayName: "Submit"
+    pool:
+      vmImage: ubuntu-latest
+    steps:
+    - task: GoTool@0
+      displayName: "Install Go 1.13"
+      inputs:
+        version: "1.13"
+    - script: echo "##vso[task.setvariable variable=PATH]${PATH}:/home/vsts/go/bin/"
+    - script: mkdir -p ${HOME}/go/src/github.com/pelletier/go-toml
+    - script: cp -R . ${HOME}/go/src/github.com/pelletier/go-toml
+    - task: Bash@3
+      inputs:
+        filePath: './fuzzit.sh'
+      env:
+        TYPE: fuzzing
+        FUZZIT_API_KEY: $(FUZZIT_API_KEY)
+
+- stage: run_checks
+  displayName: "Check"
+  dependsOn: []
+  jobs:
+  - job: fmt
+    displayName: "fmt"
+    pool:
+      vmImage: ubuntu-latest
+    steps:
+    - task: GoTool@0
+      displayName: "Install Go 1.13"
+      inputs:
+        version: "1.13"
+    - task: Go@0
+      displayName: "go fmt ./..."
+      inputs:
+        command: 'custom'
+        customCommand: 'fmt'
+        arguments: './...'
+  - job: coverage
+    displayName: "coverage"
+    pool:
+      vmImage: ubuntu-latest
+    steps:
+    - task: GoTool@0
+      displayName: "Install Go 1.13"
+      inputs:
+        version: "1.13"
+    - task: Go@0
+      displayName: "Generate coverage"
+      inputs:
+        command: 'test'
+        arguments: "-race -coverprofile=coverage.txt -covermode=atomic"
+    - task: Bash@3
+      inputs:
+        targetType: 'inline'
+        script: 'bash <(curl -s https://codecov.io/bash) -t $(CODECOV_TOKEN)'
+  - job: benchmark
+    displayName: "benchmark"
+    pool:
+      vmImage: ubuntu-latest
+    steps:
+    - task: GoTool@0
+      displayName: "Install Go 1.13"
+      inputs:
+        version: "1.13"
+    - script: echo "##vso[task.setvariable variable=PATH]${PATH}:/home/vsts/go/bin/"
+    - task: Bash@3
+      inputs:
+        filePath: './benchmark.sh'
+        arguments: "master $(Build.Repository.Uri)"
+
+  - job: fuzzing
+    displayName: "fuzzing"
+    pool:
+      vmImage: ubuntu-latest
+    steps:
+    - task: GoTool@0
+      displayName: "Install Go 1.13"
+      inputs:
+        version: "1.13"
+    - script: echo "##vso[task.setvariable variable=PATH]${PATH}:/home/vsts/go/bin/"
+    - script: mkdir -p ${HOME}/go/src/github.com/pelletier/go-toml
+    - script: cp -R . ${HOME}/go/src/github.com/pelletier/go-toml
+    - task: Bash@3
+      inputs:
+        filePath: './fuzzit.sh'
+      env:
+        TYPE: local-regression
+
+  - job: go_unit_tests
+    displayName: "unit tests"
+    strategy:
+      matrix:
+        linux 1.13:
+          goVersion: '1.13'
+          imageName: 'ubuntu-latest'
+        mac 1.13:
+          goVersion: '1.13'
+          imageName: 'macos-10.13'
+        windows 1.13:
+          goVersion: '1.13'
+          imageName: 'vs2017-win2016'
+        linux 1.12:
+          goVersion: '1.12'
+          imageName: 'ubuntu-latest'
+        mac 1.12:
+          goVersion: '1.12'
+          imageName: 'macos-10.13'
+        windows 1.12:
+          goVersion: '1.12'
+          imageName: 'vs2017-win2016'
+    pool:
+      vmImage: $(imageName)
+    steps:
+    - task: GoTool@0
+      displayName: "Install Go $(goVersion)"
+      inputs:
+        version: $(goVersion)
+    - task: Go@0
+      displayName: "go test ./..."
+      inputs:
+        command: 'test'
+        arguments: './...'
+
+- stage: build_docker_image
+  displayName: "Build Docker image"
+  dependsOn: run_checks
+  jobs:
+  - job: build
+    displayName: "Build"
+    pool:
+      vmImage: ubuntu-latest
+    steps:
+    - task: Docker@2
+      inputs:
+        command: 'build'
+        Dockerfile: 'Dockerfile'
+        buildContext: '.'
+        addPipelineData: false
+
+- stage: publish_docker_image
+  displayName: "Publish Docker image"
+  dependsOn: build_docker_image
+  condition: and(succeeded(), eq(variables['Build.SourceBranchName'], 'master'))
+  jobs:
+  - job: publish
+    displayName: "Publish"
+    pool:
+      vmImage: ubuntu-latest
+    steps:
+    - task: Docker@2
+      inputs:
+        containerRegistry: 'DockerHub'
+        repository: 'pelletier/go-toml'
+        command: 'buildAndPush'
+        Dockerfile: 'Dockerfile'
+        buildContext: '.'
+        tags: 'latest'

benchmark.sh

@@ -1,6 +1,6 @@
 #!/bin/bash
 
-set -e
+set -ex
 
 reference_ref=${1:-master}
 reference_git=${2:-.}
@@ -8,7 +8,6 @@ reference_git=${2:-.}
 if ! `hash benchstat 2>/dev/null`; then
     echo "Installing benchstat"
     go get golang.org/x/perf/cmd/benchstat
-    go install golang.org/x/perf/cmd/benchstat
 fi
 
 tempdir=`mktemp -d /tmp/go-toml-benchmark-XXXXXX`
@@ -29,4 +28,4 @@ go test -bench=. -benchmem  | tee ${local_benchmark}
 
 echo ""
 echo "=== diff"
-benchstat -delta-test=none ${ref_benchmark} ${local_benchmark}
+benchstat -delta-test=none ${ref_benchmark} ${local_benchmark}

cmd/jsontoml/main.go

@@ -0,0 +1,82 @@
+// Jsontoml reads JSON and converts to TOML.
+//
+// Usage:
+//   cat file.toml | jsontoml > file.json
+//   jsontoml file1.toml > file.json
+package main
+
+import (
+	"encoding/json"
+	"flag"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+
+	"github.com/pelletier/go-toml"
+)
+
+func main() {
+	flag.Usage = func() {
+		fmt.Fprintln(os.Stderr, "jsontoml can be used in two ways:")
+		fmt.Fprintln(os.Stderr, "Writing to STDIN and reading from STDOUT:")
+		fmt.Fprintln(os.Stderr, "")
+		fmt.Fprintln(os.Stderr, "")
+		fmt.Fprintln(os.Stderr, "Reading from a file name:")
+		fmt.Fprintln(os.Stderr, " tomljson file.toml")
+	}
+	flag.Parse()
+	os.Exit(processMain(flag.Args(), os.Stdin, os.Stdout, os.Stderr))
+}
+
+func processMain(files []string, defaultInput io.Reader, output io.Writer, errorOutput io.Writer) int {
+	// read from stdin and print to stdout
+	inputReader := defaultInput
+
+	if len(files) > 0 {
+		file, err := os.Open(files[0])
+		if err != nil {
+			printError(err, errorOutput)
+			return -1
+		}
+		inputReader = file
+		defer file.Close()
+	}
+	s, err := reader(inputReader)
+	if err != nil {
+		printError(err, errorOutput)
+		return -1
+	}
+	io.WriteString(output, s)
+	return 0
+}
+
+func printError(err error, output io.Writer) {
+	io.WriteString(output, err.Error()+"\n")
+}
+
+func reader(r io.Reader) (string, error) {
+	jsonMap := make(map[string]interface{})
+	jsonBytes, err := ioutil.ReadAll(r)
+	if err != nil {
+		return "", err
+	}
+	err = json.Unmarshal(jsonBytes, &jsonMap)
+	if err != nil {
+		return "", err
+	}
+
+	tree, err := toml.TreeFromMap(jsonMap)
+	if err != nil {
+		return "", err
+	}
+	return mapToTOML(tree)
+}
+
+func mapToTOML(t *toml.Tree) (string, error) {
+	tomlBytes, err := t.ToTomlString()
+	if err != nil {
+		return "", err
+	}
+	return string(tomlBytes[:]), nil
+}

cmd/jsontoml/main_test.go

@@ -0,0 +1,92 @@
+package main
+
+import (
+	"bytes"
+	"io/ioutil"
+	"os"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func expectBufferEquality(t *testing.T, name string, buffer *bytes.Buffer, expected string) {
+	output := buffer.String()
+	if output != expected {
+		t.Errorf("incorrect %s: \n%sexpected %s: \n%s", name, output, name, expected)
+		t.Log([]rune(output))
+		t.Log([]rune(expected))
+	}
+}
+
+func expectProcessMainResults(t *testing.T, input string, args []string, exitCode int, expectedOutput string, expectedError string) {
+	inputReader := strings.NewReader(input)
+
+	outputBuffer := new(bytes.Buffer)
+	errorBuffer := new(bytes.Buffer)
+
+	returnCode := processMain(args, inputReader, outputBuffer, errorBuffer)
+
+	expectBufferEquality(t, "output", outputBuffer, expectedOutput)
+	expectBufferEquality(t, "error", errorBuffer, expectedError)
+
+	if returnCode != exitCode {
+		t.Error("incorrect return code:", returnCode, "expected", exitCode)
+	}
+}
+
+func TestProcessMainReadFromStdin(t *testing.T) {
+	expectedOutput := `
+[mytoml]
+  a = 42.0
+`
+	input := `{
+  "mytoml": {
+    "a": 42
+  }
+}
+`
+	expectedError := ``
+	expectedExitCode := 0
+
+	expectProcessMainResults(t, input, []string{}, expectedExitCode, expectedOutput, expectedError)
+}
+
+func TestProcessMainReadFromFile(t *testing.T) {
+	input := `{
+  "mytoml": {
+    "a": 42
+  }
+}
+`
+	tmpfile, err := ioutil.TempFile("", "example.json")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := tmpfile.Write([]byte(input)); err != nil {
+		t.Fatal(err)
+	}
+
+	defer os.Remove(tmpfile.Name())
+
+	expectedOutput := `
+[mytoml]
+  a = 42.0
+`
+	expectedError := ``
+	expectedExitCode := 0
+
+	expectProcessMainResults(t, ``, []string{tmpfile.Name()}, expectedExitCode, expectedOutput, expectedError)
+}
+
+func TestProcessMainReadFromMissingFile(t *testing.T) {
+	var expectedError string
+	if runtime.GOOS == "windows" {
+		expectedError = `open /this/file/does/not/exist: The system cannot find the path specified.
+`
+	} else {
+		expectedError = `open /this/file/does/not/exist: no such file or directory
+`
+	}
+
+	expectProcessMainResults(t, ``, []string{"/this/file/does/not/exist"}, -1, ``, expectedError)
+}

cmd/test_program.go

@@ -1,91 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"fmt"
-	"io/ioutil"
-	"log"
-	"os"
-	"time"
-
-	"github.com/pelletier/go-toml"
-)
-
-func main() {
-	bytes, err := ioutil.ReadAll(os.Stdin)
-	if err != nil {
-		log.Fatalf("Error during TOML read: %s", err)
-		os.Exit(2)
-	}
-	tree, err := toml.Load(string(bytes))
-	if err != nil {
-		log.Fatalf("Error during TOML load: %s", err)
-		os.Exit(1)
-	}
-
-	typedTree := translate(*tree)
-
-	if err := json.NewEncoder(os.Stdout).Encode(typedTree); err != nil {
-		log.Fatalf("Error encoding JSON: %s", err)
-		os.Exit(3)
-	}
-
-	os.Exit(0)
-}
-
-func translate(tomlData interface{}) interface{} {
-	switch orig := tomlData.(type) {
-	case map[string]interface{}:
-		typed := make(map[string]interface{}, len(orig))
-		for k, v := range orig {
-			typed[k] = translate(v)
-		}
-		return typed
-	case *toml.Tree:
-		return translate(*orig)
-	case toml.Tree:
-		keys := orig.Keys()
-		typed := make(map[string]interface{}, len(keys))
-		for _, k := range keys {
-			typed[k] = translate(orig.GetPath([]string{k}))
-		}
-		return typed
-	case []*toml.Tree:
-		typed := make([]map[string]interface{}, len(orig))
-		for i, v := range orig {
-			typed[i] = translate(v).(map[string]interface{})
-		}
-		return typed
-	case []map[string]interface{}:
-		typed := make([]map[string]interface{}, len(orig))
-		for i, v := range orig {
-			typed[i] = translate(v).(map[string]interface{})
-		}
-		return typed
-	case []interface{}:
-		typed := make([]interface{}, len(orig))
-		for i, v := range orig {
-			typed[i] = translate(v)
-		}
-		return tag("array", typed)
-	case time.Time:
-		return tag("datetime", orig.Format("2006-01-02T15:04:05Z"))
-	case bool:
-		return tag("bool", fmt.Sprintf("%v", orig))
-	case int64:
-		return tag("integer", fmt.Sprintf("%d", orig))
-	case float64:
-		return tag("float", fmt.Sprintf("%v", orig))
-	case string:
-		return tag("string", orig)
-	}
-
-	panic(fmt.Sprintf("Unknown type: %T", tomlData))
-}
-
-func tag(typeName string, data interface{}) map[string]interface{} {
-	return map[string]interface{}{
-		"type":  typeName,
-		"value": data,
-	}
-}

cmd/tomljson/main.go

@@ -17,13 +17,12 @@ import (
 
 func main() {
 	flag.Usage = func() {
-		fmt.Fprintln(os.Stderr, `tomljson can be used in two ways:
+		fmt.Fprintln(os.Stderr, "tomljson can be used in two ways:")
-Writing to STDIN and reading from STDOUT:
+		fmt.Fprintln(os.Stderr, "Writing to STDIN and reading from STDOUT:")
-  cat file.toml | tomljson > file.json
+		fmt.Fprintln(os.Stderr, "  cat file.toml | tomljson > file.json")
-
+		fmt.Fprintln(os.Stderr, "")
-Reading from a file name:
+		fmt.Fprintln(os.Stderr, "Reading from a file name:")
-  tomljson file.toml
+		fmt.Fprintln(os.Stderr, "  tomljson file.toml")
-`)
 	}
 	flag.Parse()
 	os.Exit(processMain(flag.Args(), os.Stdin, os.Stdout, os.Stderr))

cmd/tomljson/main_test.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"io/ioutil"
 	"os"
+	"runtime"
 	"strings"
 	"testing"
 )
@@ -76,7 +77,14 @@ func TestProcessMainReadFromFile(t *testing.T) {
 }
 
 func TestProcessMainReadFromMissingFile(t *testing.T) {
-	expectedError := `open /this/file/does/not/exist: no such file or directory
+	var expectedError string
+	if runtime.GOOS == "windows" {
+		expectedError = `open /this/file/does/not/exist: The system cannot find the path specified.
 `
+	} else {
+		expectedError = `open /this/file/does/not/exist: no such file or directory
+`
+	}
+
 	expectProcessMainResults(t, ``, []string{"/this/file/does/not/exist"}, -1, ``, expectedError)
 }

cmd/tomll/main.go

@@ -17,15 +17,14 @@ import (
 
 func main() {
 	flag.Usage = func() {
-		fmt.Fprintln(os.Stderr, `tomll can be used in two ways:
+		fmt.Fprintln(os.Stderr, "tomll can be used in two ways:")
-Writing to STDIN and reading from STDOUT:
+		fmt.Fprintln(os.Stderr, "Writing to STDIN and reading from STDOUT:")
-  cat file.toml | tomll > file.toml
+		fmt.Fprintln(os.Stderr, "  cat file.toml | tomll > file.toml")
-
+		fmt.Fprintln(os.Stderr, "")
-Reading and updating a list of files:
+		fmt.Fprintln(os.Stderr, "Reading and updating a list of files:")
-  tomll a.toml b.toml c.toml
+		fmt.Fprintln(os.Stderr, "  tomll a.toml b.toml c.toml")
-
+		fmt.Fprintln(os.Stderr, "")
-When given a list of files, tomll will modify all files in place without asking.
+		fmt.Fprintln(os.Stderr, "When given a list of files, tomll will modify all files in place without asking.")
-`)
 	}
 	flag.Parse()
 	// read from stdin and print to stdout

cmd/tomltestgen/main.go

@@ -0,0 +1,219 @@
+// Tomltestgen is a program that retrieves a given version of
+// https://github.com/BurntSushi/toml-test and generates go code for go-toml's unit tests
+// based on the test files.
+//
+// Usage: go run github.com/pelletier/go-toml/cmd/tomltestgen > toml_testgen_test.go
+package main
+
+import (
+	"archive/zip"
+	"bytes"
+	"flag"
+	"fmt"
+	"go/format"
+	"io"
+	"io/ioutil"
+	"log"
+	"net/http"
+	"os"
+	"regexp"
+	"strconv"
+	"strings"
+	"text/template"
+	"time"
+)
+
+type invalid struct {
+	Name  string
+	Input string
+}
+
+type valid struct {
+	Name    string
+	Input   string
+	JsonRef string
+}
+
+type testsCollection struct {
+	Ref       string
+	Timestamp string
+	Invalid   []invalid
+	Valid     []valid
+	Count     int
+}
+
+const srcTemplate = "// Generated by tomltestgen for toml-test ref {{.Ref}} on {{.Timestamp}}\n" +
+	"package toml\n" +
+	" import (\n" +
+	"	\"testing\"\n" +
+	")\n" +
+
+	"{{range .Invalid}}\n" +
+	"func TestInvalid{{.Name}}(t *testing.T) {\n" +
+	"	input := {{.Input|gostr}}\n" +
+	"	testgenInvalid(t, input)\n" +
+	"}\n" +
+	"{{end}}\n" +
+	"\n" +
+	"{{range .Valid}}\n" +
+	"func TestValid{{.Name}}(t *testing.T) {\n" +
+	"   input := {{.Input|gostr}}\n" +
+	"   jsonRef := {{.JsonRef|gostr}}\n" +
+	"   testgenValid(t, input, jsonRef)\n" +
+	"}\n" +
+	"{{end}}\n"
+
+func downloadTmpFile(url string) string {
+	log.Println("starting to download file from", url)
+	resp, err := http.Get(url)
+	if err != nil {
+		panic(err)
+	}
+	defer resp.Body.Close()
+
+	tmpfile, err := ioutil.TempFile("", "toml-test-*.zip")
+	if err != nil {
+		panic(err)
+	}
+	defer tmpfile.Close()
+
+	copiedLen, err := io.Copy(tmpfile, resp.Body)
+	if err != nil {
+		panic(err)
+	}
+	if resp.ContentLength > 0 && copiedLen != resp.ContentLength {
+		panic(fmt.Errorf("copied %d bytes, request body had %d", copiedLen, resp.ContentLength))
+	}
+	return tmpfile.Name()
+}
+
+func kebabToCamel(kebab string) string {
+	camel := ""
+	nextUpper := true
+	for _, c := range kebab {
+		if nextUpper {
+			camel += strings.ToUpper(string(c))
+			nextUpper = false
+		} else if c == '-' {
+			nextUpper = true
+		} else {
+			camel += string(c)
+		}
+	}
+	return camel
+}
+
+func readFileFromZip(f *zip.File) string {
+	reader, err := f.Open()
+	if err != nil {
+		panic(err)
+	}
+	defer reader.Close()
+	bytes, err := ioutil.ReadAll(reader)
+	if err != nil {
+		panic(err)
+	}
+	return string(bytes)
+}
+
+func templateGoStr(input string) string {
+	if len(input) > 0 && input[len(input)-1] == '\n' {
+		input = input[0 : len(input)-1]
+	}
+	if strings.Contains(input, "`") {
+		lines := strings.Split(input, "\n")
+		for idx, line := range lines {
+			lines[idx] = strconv.Quote(line + "\n")
+		}
+		return strings.Join(lines, " + \n")
+	}
+	return "`" + input + "`"
+}
+
+var (
+	ref = flag.String("r", "master", "git reference")
+)
+
+func usage() {
+	_, _ = fmt.Fprintf(os.Stderr, "usage: tomltestgen [flags]\n")
+	flag.PrintDefaults()
+}
+
+func main() {
+	flag.Usage = usage
+	flag.Parse()
+
+	url := "https://codeload.github.com/BurntSushi/toml-test/zip/" + *ref
+	resultFile := downloadTmpFile(url)
+	defer os.Remove(resultFile)
+	log.Println("file written to", resultFile)
+
+	zipReader, err := zip.OpenReader(resultFile)
+	if err != nil {
+		panic(err)
+	}
+	defer zipReader.Close()
+
+	collection := testsCollection{
+		Ref:       *ref,
+		Timestamp: time.Now().Format(time.RFC3339),
+	}
+
+	zipFilesMap := map[string]*zip.File{}
+
+	for _, f := range zipReader.File {
+		zipFilesMap[f.Name] = f
+	}
+
+	testFileRegexp := regexp.MustCompile(`([^/]+/tests/(valid|invalid)/(.+))\.(toml)`)
+	for _, f := range zipReader.File {
+		groups := testFileRegexp.FindStringSubmatch(f.Name)
+		if len(groups) > 0 {
+			name := kebabToCamel(groups[3])
+			testType := groups[2]
+
+			log.Printf("> [%s] %s\n", testType, name)
+
+			tomlContent := readFileFromZip(f)
+
+			switch testType {
+			case "invalid":
+				collection.Invalid = append(collection.Invalid, invalid{
+					Name:  name,
+					Input: tomlContent,
+				})
+				collection.Count++
+			case "valid":
+				baseFilePath := groups[1]
+				jsonFilePath := baseFilePath + ".json"
+				jsonContent := readFileFromZip(zipFilesMap[jsonFilePath])
+
+				collection.Valid = append(collection.Valid, valid{
+					Name:    name,
+					Input:   tomlContent,
+					JsonRef: jsonContent,
+				})
+				collection.Count++
+			default:
+				panic(fmt.Sprintf("unknown test type: %s", testType))
+			}
+		}
+	}
+
+	log.Printf("Collected %d tests from toml-test\n", collection.Count)
+
+	funcMap := template.FuncMap{
+		"gostr": templateGoStr,
+	}
+	t := template.Must(template.New("src").Funcs(funcMap).Parse(srcTemplate))
+	buf := new(bytes.Buffer)
+	err = t.Execute(buf, collection)
+	if err != nil {
+		panic(err)
+	}
+	outputBytes, err := format.Source(buf.Bytes())
+	if err != nil {
+		panic(err)
+	}
+	fmt.Println(string(outputBytes))
+}

doc.go

@@ -17,7 +17,7 @@
 // JSONPath-like queries
 //
 // The package github.com/pelletier/go-toml/query implements a system
-// similar to JSONPath to quickly retrive elements of a TOML document using a
+// similar to JSONPath to quickly retrieve elements of a TOML document using a
 // single expression. See the package documentation for more information.
 //
 package toml

doc_test.go

@@ -16,13 +16,14 @@ func Example_tree() {
 		fmt.Println("Error ", err.Error())
 	} else {
 		// retrieve data directly
-		user := config.Get("postgres.user").(string)
+		directUser := config.Get("postgres.user").(string)
-		password := config.Get("postgres.password").(string)
+		directPassword := config.Get("postgres.password").(string)
+		fmt.Println("User is", directUser, " and password is", directPassword)
 
 		// or using an intermediate object
 		configTree := config.Get("postgres").(*toml.Tree)
-		user = configTree.Get("user").(string)
+		user := configTree.Get("user").(string)
-		password = configTree.Get("password").(string)
+		password := configTree.Get("password").(string)
 		fmt.Println("User is", user, " and password is", password)
 
 		// show where elements are in the file
@@ -61,19 +62,24 @@ func ExampleMarshal() {
 	type Postgres struct {
 		User     string `toml:"user"`
 		Password string `toml:"password"`
+		Database string `toml:"db" commented:"true" comment:"not used anymore"`
 	}
 	type Config struct {
-		Postgres Postgres `toml:"postgres"`
+		Postgres Postgres `toml:"postgres" comment:"Postgres configuration"`
 	}
 
-	config := Config{Postgres{User: "pelletier", Password: "mypassword"}}
+	config := Config{Postgres{User: "pelletier", Password: "mypassword", Database: "old_database"}}
 	b, err := toml.Marshal(config)
 	if err != nil {
 		log.Fatal(err)
 	}
 	fmt.Println(string(b))
 	// Output:
+	// # Postgres configuration
 	// [postgres]
+	//
+	//   # not used anymore
+	//   # db = "old_database"
 	//   password = "mypassword"
 	//   user = "pelletier"
 }

fuzz.go

@@ -0,0 +1,31 @@
+// +build gofuzz
+
+package toml
+
+func Fuzz(data []byte) int {
+	tree, err := LoadBytes(data)
+	if err != nil {
+		if tree != nil {
+			panic("tree must be nil if there is an error")
+		}
+		return 0
+	}
+
+	str, err := tree.ToTomlString()
+	if err != nil {
+		if str != "" {
+			panic(`str must be "" if there is an error`)
+		}
+		panic(err)
+	}
+
+	tree, err = Load(str)
+	if err != nil {
+		if tree != nil {
+			panic("tree must be nil if there is an error")
+		}
+		return 0
+	}
+
+	return 1
+}

fuzz.sh

@@ -0,0 +1,15 @@
+#! /bin/sh
+set -eu
+
+go get github.com/dvyukov/go-fuzz/go-fuzz
+go get github.com/dvyukov/go-fuzz/go-fuzz-build
+
+if [ ! -e toml-fuzz.zip ]; then
+    go-fuzz-build github.com/pelletier/go-toml
+fi
+
+rm -fr fuzz
+mkdir -p fuzz/corpus
+cp *.toml fuzz/corpus
+
+go-fuzz -bin=toml-fuzz.zip -workdir=fuzz

fuzzit.sh

@@ -0,0 +1,26 @@
+#!/bin/bash
+set -xe
+
+# go-fuzz doesn't support modules yet, so ensure we do everything
+# in the old style GOPATH way
+export GO111MODULE="off"
+
+# install go-fuzz
+go get -u github.com/dvyukov/go-fuzz/go-fuzz github.com/dvyukov/go-fuzz/go-fuzz-build
+
+# target name can only contain lower-case letters (a-z), digits (0-9) and a dash (-)
+# to add another target, make sure to create it with `fuzzit create target`
+# before using `fuzzit create job`
+TARGET=toml-fuzzer
+
+go-fuzz-build -libfuzzer -o ${TARGET}.a github.com/pelletier/go-toml
+clang -fsanitize=fuzzer ${TARGET}.a -o ${TARGET}
+
+# install fuzzit for talking to fuzzit.dev service
+# or latest version:
+# https://github.com/fuzzitdev/fuzzit/releases/latest/download/fuzzit_Linux_x86_64
+wget -q -O fuzzit https://github.com/fuzzitdev/fuzzit/releases/download/v2.4.52/fuzzit_Linux_x86_64
+chmod a+x fuzzit
+
+# TODO: change kkowalczyk to go-toml and create toml-fuzzer target there
+./fuzzit create job --type $TYPE go-toml/${TARGET} ${TARGET}

go.mod

@@ -0,0 +1,9 @@
+module github.com/pelletier/go-toml
+
+go 1.12
+
+require (
+	github.com/BurntSushi/toml v0.3.1
+	github.com/davecgh/go-spew v1.1.1
+	gopkg.in/yaml.v2 v2.2.4
+)

go.sum

@@ -0,0 +1,11 @@
+github.com/BurntSushi/toml v0.3.1 h1:WXkYYl6Yr3qBf1K79EBnL4mak0OimBfB0XUf9Vl28OQ=
+github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.3 h1:fvjTMHxHEw/mxHbtzPi3JCcKXQRAnQTBRo6YCJSVHKI=
+gopkg.in/yaml.v2 v2.2.3/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.4 h1:/eiJrUcujPVeJ3xlSWaiNi3uSVmDGBK1pDHUHAnao1I=
+gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=

keysparsing.go

@@ -3,88 +3,107 @@
 package toml
 
 import (
-	"bytes"
 	"errors"
 	"fmt"
 	"unicode"
 )
 
+// Convert the bare key group string to an array.
+// The input supports double quotation and single quotation,
+// but escape sequences are not supported. Lexers must unescape them beforehand.
 func parseKey(key string) ([]string, error) {
-	groups := []string{}
+	runes := []rune(key)
-	var buffer bytes.Buffer
+	var groups []string
-	inQuotes := false
-	wasInQuotes := false
-	escapeNext := false
-	ignoreSpace := true
-	expectDot := false
 
-	for _, char := range key {
+	if len(key) == 0 {
-		if ignoreSpace {
+		return nil, errors.New("empty key")
-			if char == ' ' {
+	}
-				continue
+
-			}
+	idx := 0
-			ignoreSpace = false
+	for idx < len(runes) {
+		for ; idx < len(runes) && isSpace(runes[idx]); idx++ {
+			// skip leading whitespace
 		}
-		if escapeNext {
+		if idx >= len(runes) {
-			buffer.WriteRune(char)
+			break
-			escapeNext = false
-			continue
 		}
-		switch char {
+		r := runes[idx]
-		case '\\':
+		if isValidBareChar(r) {
-			escapeNext = true
+			// parse bare key
-			continue
+			startIdx := idx
-		case '"':
+			endIdx := -1
-			if inQuotes {
+			idx++
-				groups = append(groups, buffer.String())
+			for idx < len(runes) {
-				buffer.Reset()
+				r = runes[idx]
-				wasInQuotes = true
+				if isValidBareChar(r) {
-			}
+					idx++
-			inQuotes = !inQuotes
+				} else if r == '.' {
-			expectDot = false
+					endIdx = idx
-		case '.':
+					break
-			if inQuotes {
+				} else if isSpace(r) {
-				buffer.WriteRune(char)
+					endIdx = idx
-			} else {
+					for ; idx < len(runes) && isSpace(runes[idx]); idx++ {
-				if !wasInQuotes {
+						// skip trailing whitespace
-					if buffer.Len() == 0 {
-						return nil, errors.New("empty table key")
 					}
-					groups = append(groups, buffer.String())
+					if idx < len(runes) && runes[idx] != '.' {
-					buffer.Reset()
+						return nil, fmt.Errorf("invalid key character after whitespace: %c", runes[idx])
+					}
+					break
+				} else {
+					return nil, fmt.Errorf("invalid bare key character: %c", r)
 				}
-				ignoreSpace = true
-				expectDot = false
-				wasInQuotes = false
 			}
-		case ' ':
+			if endIdx == -1 {
-			if inQuotes {
+				endIdx = idx
-				buffer.WriteRune(char)
-			} else {
-				expectDot = true
 			}
-		default:
+			groups = append(groups, string(runes[startIdx:endIdx]))
-			if !inQuotes && !isValidBareChar(char) {
+		} else if r == '\'' {
-				return nil, fmt.Errorf("invalid bare character: %c", char)
+			// parse single quoted key
+			idx++
+			startIdx := idx
+			for {
+				if idx >= len(runes) {
+					return nil, fmt.Errorf("unclosed single-quoted key")
+				}
+				r = runes[idx]
+				if r == '\'' {
+					groups = append(groups, string(runes[startIdx:idx]))
+					idx++
+					break
+				}
+				idx++
 			}
-			if !inQuotes && expectDot {
+		} else if r == '"' {
-				return nil, errors.New("what?")
+			// parse double quoted key
+			idx++
+			startIdx := idx
+			for {
+				if idx >= len(runes) {
+					return nil, fmt.Errorf("unclosed double-quoted key")
+				}
+				r = runes[idx]
+				if r == '"' {
+					groups = append(groups, string(runes[startIdx:idx]))
+					idx++
+					break
+				}
+				idx++
 			}
-			buffer.WriteRune(char)
+		} else if r == '.' {
-			expectDot = false
+			idx++
+			if idx >= len(runes) {
+				return nil, fmt.Errorf("unexpected end of key")
+			}
+			r = runes[idx]
+			if !isValidBareChar(r) && r != '\'' && r != '"' && r != ' ' {
+				return nil, fmt.Errorf("expecting key part after dot")
+			}
+		} else {
+			return nil, fmt.Errorf("invalid key character: %c", r)
 		}
 	}
-	if inQuotes {
-		return nil, errors.New("mismatched quotes")
-	}
-	if escapeNext {
-		return nil, errors.New("unfinished escape sequence")
-	}
-	if buffer.Len() > 0 {
-		groups = append(groups, buffer.String())
-	}
 	if len(groups) == 0 {
-		return nil, errors.New("empty key")
+		return nil, fmt.Errorf("empty key")
 	}
 	return groups, nil
 }

keysparsing_test.go

@@ -22,7 +22,10 @@ func testResult(t *testing.T, key string, expected []string) {
 }
 
 func testError(t *testing.T, key string, expectedError string) {
-	_, err := parseKey(key)
+	res, err := parseKey(key)
+	if err == nil {
+		t.Fatalf("Expected error, but successfully parsed key %s", res)
+	}
 	if fmt.Sprintf("%s", err) != expectedError {
 		t.Fatalf("Expected error \"%s\", but got \"%s\".", expectedError, err)
 	}
@@ -41,16 +44,36 @@ func TestDottedKeyBasic(t *testing.T) {
 }
 
 func TestBaseKeyPound(t *testing.T) {
-	testError(t, "hello#world", "invalid bare character: #")
+	testError(t, "hello#world", "invalid bare key character: #")
+}
+
+func TestUnclosedSingleQuotedKey(t *testing.T) {
+	testError(t, "'", "unclosed single-quoted key")
+}
+
+func TestUnclosedDoubleQuotedKey(t *testing.T) {
+	testError(t, "\"", "unclosed double-quoted key")
+}
+
+func TestInvalidStartKeyCharacter(t *testing.T) {
+	testError(t, "/", "invalid key character: /")
+}
+
+func TestInvalidSpaceInKey(t *testing.T) {
+	testError(t, "invalid key", "invalid key character after whitespace: k")
 }
 
 func TestQuotedKeys(t *testing.T) {
 	testResult(t, `hello."foo".bar`, []string{"hello", "foo", "bar"})
 	testResult(t, `"hello!"`, []string{"hello!"})
+	testResult(t, `foo."ba.r".baz`, []string{"foo", "ba.r", "baz"})
+
+	// escape sequences must not be converted
+	testResult(t, `"hello\tworld"`, []string{`hello\tworld`})
 }
 
 func TestEmptyKey(t *testing.T) {
-	testError(t, "", "empty key")
+	testError(t, ``, "empty key")
-	testError(t, " ", "empty key")
+	testError(t, ` `, "empty key")
 	testResult(t, `""`, []string{""})
 }

lexer.go

@@ -204,6 +204,14 @@ func (l *tomlLexer) lexRvalue() tomlLexStateFn {
 			return l.lexFalse
 		}
 
+		if l.follow("inf") {
+			return l.lexInf
+		}
+
+		if l.follow("nan") {
+			return l.lexNan
+		}
+
 		if isSpace(next) {
 			l.skip()
 			continue
@@ -265,6 +273,18 @@ func (l *tomlLexer) lexFalse() tomlLexStateFn {
 	return l.lexRvalue
 }
 
+func (l *tomlLexer) lexInf() tomlLexStateFn {
+	l.fastForward(3)
+	l.emit(tokenInf)
+	return l.lexRvalue
+}
+
+func (l *tomlLexer) lexNan() tomlLexStateFn {
+	l.fastForward(3)
+	l.emit(tokenNan)
+	return l.lexRvalue
+}
+
 func (l *tomlLexer) lexEqual() tomlLexStateFn {
 	l.next()
 	l.emit(tokenEqual)
@@ -277,6 +297,8 @@ func (l *tomlLexer) lexComma() tomlLexStateFn {
 	return l.lexRvalue
 }
 
+// Parse the key and emits its value without escape sequences.
+// bare keys, basic string keys and literal string keys are supported.
 func (l *tomlLexer) lexKey() tomlLexStateFn {
 	growingString := ""
 
@@ -287,13 +309,24 @@ func (l *tomlLexer) lexKey() tomlLexStateFn {
 			if err != nil {
 				return l.errorf(err.Error())
 			}
-			growingString += `"` + str + `"`
+			growingString += "\"" + str + "\""
+			l.next()
+			continue
+		} else if r == '\'' {
+			l.next()
+			str, err := l.lexLiteralStringAsString(`'`, false)
+			if err != nil {
+				return l.errorf(err.Error())
+			}
+			growingString += "'" + str + "'"
 			l.next()
 			continue
 		} else if r == '\n' {
 			return l.errorf("keys cannot contain new lines")
 		} else if isSpace(r) {
 			break
+		} else if r == '.' {
+			// skip
 		} else if !isValidBareChar(r) {
 			return l.errorf("keys cannot contain %c character", r)
 		}
@@ -527,6 +560,7 @@ func (l *tomlLexer) lexTableKey() tomlLexStateFn {
 	return l.lexInsideTableKey
 }
 
+// Parse the key till "]]", but only bare keys are supported
 func (l *tomlLexer) lexInsideTableArrayKey() tomlLexStateFn {
 	for r := l.peek(); r != eof; r = l.peek() {
 		switch r {
@@ -550,6 +584,7 @@ func (l *tomlLexer) lexInsideTableArrayKey() tomlLexStateFn {
 	return l.errorf("unclosed table array key")
 }
 
+// Parse the key till "]" but only bare keys are supported
 func (l *tomlLexer) lexInsideTableKey() tomlLexStateFn {
 	for r := l.peek(); r != eof; r = l.peek() {
 		switch r {
@@ -575,11 +610,77 @@ func (l *tomlLexer) lexRightBracket() tomlLexStateFn {
 	return l.lexRvalue
 }
 
+type validRuneFn func(r rune) bool
+
+func isValidHexRune(r rune) bool {
+	return r >= 'a' && r <= 'f' ||
+		r >= 'A' && r <= 'F' ||
+		r >= '0' && r <= '9' ||
+		r == '_'
+}
+
+func isValidOctalRune(r rune) bool {
+	return r >= '0' && r <= '7' || r == '_'
+}
+
+func isValidBinaryRune(r rune) bool {
+	return r == '0' || r == '1' || r == '_'
+}
+
 func (l *tomlLexer) lexNumber() tomlLexStateFn {
 	r := l.peek()
+
+	if r == '0' {
+		follow := l.peekString(2)
+		if len(follow) == 2 {
+			var isValidRune validRuneFn
+			switch follow[1] {
+			case 'x':
+				isValidRune = isValidHexRune
+			case 'o':
+				isValidRune = isValidOctalRune
+			case 'b':
+				isValidRune = isValidBinaryRune
+			default:
+				if follow[1] >= 'a' && follow[1] <= 'z' || follow[1] >= 'A' && follow[1] <= 'Z' {
+					return l.errorf("unknown number base: %s. possible options are x (hex) o (octal) b (binary)", string(follow[1]))
+				}
+			}
+
+			if isValidRune != nil {
+				l.next()
+				l.next()
+				digitSeen := false
+				for {
+					next := l.peek()
+					if !isValidRune(next) {
+						break
+					}
+					digitSeen = true
+					l.next()
+				}
+
+				if !digitSeen {
+					return l.errorf("number needs at least one digit")
+				}
+
+				l.emit(tokenInteger)
+
+				return l.lexRvalue
+			}
+		}
+	}
+
 	if r == '+' || r == '-' {
 		l.next()
+		if l.follow("inf") {
+			return l.lexInf
+		}
+		if l.follow("nan") {
+			return l.lexNan
+		}
 	}
+
 	pointSeen := false
 	expSeen := false
 	digitSeen := false
@@ -632,7 +733,7 @@ func (l *tomlLexer) run() {
 }
 
 func init() {
-	dateRegexp = regexp.MustCompile(`^\d{1,4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{1,9})?(Z|[+-]\d{2}:\d{2})`)
+	dateRegexp = regexp.MustCompile(`^\d{1,4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(\.\d{1,9})?(Z|[+-]\d{2}:\d{2})`)
 }
 
 // Entry point

lexer_test.go

@@ -299,6 +299,9 @@ func TestDateRegexp(t *testing.T) {
 	if dateRegexp.FindString("1979-05-27T00:32:00.999999-07:00") == "" {
 		t.Error("nano precision lexing")
 	}
+	if dateRegexp.FindString("1979-05-27 07:32:00Z") == "" {
+		t.Error("space delimiter lexing")
+	}
 }
 
 func TestKeyEqualDate(t *testing.T) {
@@ -320,6 +323,12 @@ func TestKeyEqualDate(t *testing.T) {
 		{Position{1, 7}, tokenDate, "1979-05-27T00:32:00.999999-07:00"},
 		{Position{1, 39}, tokenEOF, ""},
 	})
+	testFlow(t, "foo = 1979-05-27 07:32:00Z", []token{
+		{Position{1, 1}, tokenKey, "foo"},
+		{Position{1, 5}, tokenEqual, "="},
+		{Position{1, 7}, tokenDate, "1979-05-27 07:32:00Z"},
+		{Position{1, 27}, tokenEOF, ""},
+	})
 }
 
 func TestFloatEndingWithDot(t *testing.T) {

marshal.go

@@ -4,21 +4,72 @@ import (
 	"bytes"
 	"errors"
 	"fmt"
+	"io"
 	"reflect"
+	"sort"
+	"strconv"
 	"strings"
 	"time"
 )
 
+const (
+	tagFieldName    = "toml"
+	tagFieldComment = "comment"
+	tagCommented    = "commented"
+	tagMultiline    = "multiline"
+	tagDefault      = "default"
+)
+
 type tomlOpts struct {
-	name      string
+	name         string
-	include   bool
+	comment      string
-	omitempty bool
+	commented    bool
+	multiline    bool
+	include      bool
+	omitempty    bool
+	defaultValue string
 }
 
+type encOpts struct {
+	quoteMapKeys            bool
+	arraysOneElementPerLine bool
+}
+
+var encOptsDefaults = encOpts{
+	quoteMapKeys: false,
+}
+
+type annotation struct {
+	tag          string
+	comment      string
+	commented    string
+	multiline    string
+	defaultValue string
+}
+
+var annotationDefault = annotation{
+	tag:          tagFieldName,
+	comment:      tagFieldComment,
+	commented:    tagCommented,
+	multiline:    tagMultiline,
+	defaultValue: tagDefault,
+}
+
+type marshalOrder int
+
+// Orders the Encoder can write the fields to the output stream.
+const (
+	// Sort fields alphabetically.
+	OrderAlphabetical marshalOrder = iota + 1
+	// Preserve the order the fields are encountered. For example, the order of fields in
+	// a struct.
+	OrderPreserve
+)
+
 var timeType = reflect.TypeOf(time.Time{})
 var marshalerType = reflect.TypeOf(new(Marshaler)).Elem()
 
-// Check if the given marshall type maps to a Tree primitive
+// Check if the given marshal type maps to a Tree primitive
 func isPrimitive(mtype reflect.Type) bool {
 	switch mtype.Kind() {
 	case reflect.Ptr:
@@ -40,7 +91,7 @@ func isPrimitive(mtype reflect.Type) bool {
 	}
 }
 
-// Check if the given marshall type maps to a Tree slice
+// Check if the given marshal type maps to a Tree slice
 func isTreeSlice(mtype reflect.Type) bool {
 	switch mtype.Kind() {
 	case reflect.Slice:
@@ -50,7 +101,7 @@ func isTreeSlice(mtype reflect.Type) bool {
 	}
 }
 
-// Check if the given marshall type maps to a non-Tree slice
+// Check if the given marshal type maps to a non-Tree slice
 func isOtherSlice(mtype reflect.Type) bool {
 	switch mtype.Kind() {
 	case reflect.Ptr:
@@ -62,7 +113,7 @@ func isOtherSlice(mtype reflect.Type) bool {
 	}
 }
 
-// Check if the given marshall type maps to a Tree
+// Check if the given marshal type maps to a Tree
 func isTree(mtype reflect.Type) bool {
 	switch mtype.Kind() {
 	case reflect.Map:
@@ -94,8 +145,15 @@ encoder, except that there is no concept of a Marshaler interface or MarshalTOML
 function for sub-structs, and currently only definite types can be marshaled
 (i.e. no `interface{}`).
 
+The following struct annotations are supported:
+
+  toml:"Field"      Overrides the field's name to output.
+  omitempty         When set, empty values and groups are not emitted.
+  comment:"comment" Emits a # comment on the same line. This supports new lines.
+  commented:"true"  Emits the value as commented.
+
 Note that pointers are automatically assigned the "omitempty" option, as TOML
-explicity does not handle null values (saying instead the label should be
+explicitly does not handle null values (saying instead the label should be
 dropped).
 
 Tree structural types and corresponding marshal types:
@@ -113,61 +171,209 @@ Tree primitive types and corresponding marshal types:
   string     string, pointers to same
   bool       bool, pointers to same
   time.Time  time.Time{}, pointers to same
+
+For additional flexibility, use the Encoder API.
 */
 func Marshal(v interface{}) ([]byte, error) {
-	mtype := reflect.TypeOf(v)
+	return NewEncoder(nil).marshal(v)
-	if mtype.Kind() != reflect.Struct {
+}
-		return []byte{}, errors.New("Only a struct can be marshaled to TOML")
+
+// Encoder writes TOML values to an output stream.
+type Encoder struct {
+	w io.Writer
+	encOpts
+	annotation
+	line  int
+	col   int
+	order marshalOrder
+}
+
+// NewEncoder returns a new encoder that writes to w.
+func NewEncoder(w io.Writer) *Encoder {
+	return &Encoder{
+		w:          w,
+		encOpts:    encOptsDefaults,
+		annotation: annotationDefault,
+		line:       0,
+		col:        1,
+		order:      OrderAlphabetical,
 	}
+}
+
+// Encode writes the TOML encoding of v to the stream.
+//
+// See the documentation for Marshal for details.
+func (e *Encoder) Encode(v interface{}) error {
+	b, err := e.marshal(v)
+	if err != nil {
+		return err
+	}
+	if _, err := e.w.Write(b); err != nil {
+		return err
+	}
+	return nil
+}
+
+// QuoteMapKeys sets up the encoder to encode
+// maps with string type keys with quoted TOML keys.
+//
+// This relieves the character limitations on map keys.
+func (e *Encoder) QuoteMapKeys(v bool) *Encoder {
+	e.quoteMapKeys = v
+	return e
+}
+
+// ArraysWithOneElementPerLine sets up the encoder to encode arrays
+// with more than one element on multiple lines instead of one.
+//
+// For example:
+//
+//   A = [1,2,3]
+//
+// Becomes
+//
+//   A = [
+//     1,
+//     2,
+//     3,
+//   ]
+func (e *Encoder) ArraysWithOneElementPerLine(v bool) *Encoder {
+	e.arraysOneElementPerLine = v
+	return e
+}
+
+// Order allows to change in which order fields will be written to the output stream.
+func (e *Encoder) Order(ord marshalOrder) *Encoder {
+	e.order = ord
+	return e
+}
+
+// SetTagName allows changing default tag "toml"
+func (e *Encoder) SetTagName(v string) *Encoder {
+	e.tag = v
+	return e
+}
+
+// SetTagComment allows changing default tag "comment"
+func (e *Encoder) SetTagComment(v string) *Encoder {
+	e.comment = v
+	return e
+}
+
+// SetTagCommented allows changing default tag "commented"
+func (e *Encoder) SetTagCommented(v string) *Encoder {
+	e.commented = v
+	return e
+}
+
+// SetTagMultiline allows changing default tag "multiline"
+func (e *Encoder) SetTagMultiline(v string) *Encoder {
+	e.multiline = v
+	return e
+}
+
+func (e *Encoder) marshal(v interface{}) ([]byte, error) {
+	mtype := reflect.TypeOf(v)
+
+	switch mtype.Kind() {
+	case reflect.Struct, reflect.Map:
+	case reflect.Ptr:
+		if mtype.Elem().Kind() != reflect.Struct {
+			return []byte{}, errors.New("Only pointer to struct can be marshaled to TOML")
+		}
+	default:
+		return []byte{}, errors.New("Only a struct or map can be marshaled to TOML")
+	}
+
 	sval := reflect.ValueOf(v)
 	if isCustomMarshaler(mtype) {
 		return callCustomMarshaler(sval)
 	}
-	t, err := valueToTree(mtype, sval)
+	t, err := e.valueToTree(mtype, sval)
 	if err != nil {
 		return []byte{}, err
 	}
-	s, err := t.ToTomlString()
+
-	return []byte(s), err
+	var buf bytes.Buffer
+	_, err = t.writeToOrdered(&buf, "", "", 0, e.arraysOneElementPerLine, e.order)
+
+	return buf.Bytes(), err
+}
+
+// Create next tree with a position based on Encoder.line
+func (e *Encoder) nextTree() *Tree {
+	return newTreeWithPosition(Position{Line: e.line, Col: 1})
 }
 
 // Convert given marshal struct or map value to toml tree
-func valueToTree(mtype reflect.Type, mval reflect.Value) (*Tree, error) {
+func (e *Encoder) valueToTree(mtype reflect.Type, mval reflect.Value) (*Tree, error) {
 	if mtype.Kind() == reflect.Ptr {
-		return valueToTree(mtype.Elem(), mval.Elem())
+		return e.valueToTree(mtype.Elem(), mval.Elem())
 	}
-	tval := newTree()
+	tval := e.nextTree()
 	switch mtype.Kind() {
 	case reflect.Struct:
 		for i := 0; i < mtype.NumField(); i++ {
 			mtypef, mvalf := mtype.Field(i), mval.Field(i)
-			opts := tomlOptions(mtypef)
+			opts := tomlOptions(mtypef, e.annotation)
 			if opts.include && (!opts.omitempty || !isZero(mvalf)) {
-				val, err := valueToToml(mtypef.Type, mvalf)
+				val, err := e.valueToToml(mtypef.Type, mvalf)
 				if err != nil {
 					return nil, err
 				}
-				tval.Set(opts.name, val)
+
+				tval.SetWithOptions(opts.name, SetOptions{
+					Comment:   opts.comment,
+					Commented: opts.commented,
+					Multiline: opts.multiline,
+				}, val)
 			}
 		}
 	case reflect.Map:
-		for _, key := range mval.MapKeys() {
+		keys := mval.MapKeys()
+		if e.order == OrderPreserve && len(keys) > 0 {
+			// Sorting []reflect.Value is not straight forward.
+			//
+			// OrderPreserve will support deterministic results when string is used
+			// as the key to maps.
+			typ := keys[0].Type()
+			kind := keys[0].Kind()
+			if kind == reflect.String {
+				ikeys := make([]string, len(keys))
+				for i := range keys {
+					ikeys[i] = keys[i].Interface().(string)
+				}
+				sort.Strings(ikeys)
+				for i := range ikeys {
+					keys[i] = reflect.ValueOf(ikeys[i]).Convert(typ)
+				}
+			}
+		}
+		for _, key := range keys {
 			mvalf := mval.MapIndex(key)
-			val, err := valueToToml(mtype.Elem(), mvalf)
+			val, err := e.valueToToml(mtype.Elem(), mvalf)
 			if err != nil {
 				return nil, err
 			}
-			tval.Set(key.String(), val)
+			if e.quoteMapKeys {
+				keyStr, err := tomlValueStringRepresentation(key.String(), "", e.arraysOneElementPerLine)
+				if err != nil {
+					return nil, err
+				}
+				tval.SetPath([]string{keyStr}, val)
+			} else {
+				tval.Set(key.String(), val)
+			}
 		}
 	}
 	return tval, nil
 }
 
 // Convert given marshal slice to slice of Toml trees
-func valueToTreeSlice(mtype reflect.Type, mval reflect.Value) ([]*Tree, error) {
+func (e *Encoder) valueToTreeSlice(mtype reflect.Type, mval reflect.Value) ([]*Tree, error) {
 	tval := make([]*Tree, mval.Len(), mval.Len())
 	for i := 0; i < mval.Len(); i++ {
-		val, err := valueToTree(mtype.Elem(), mval.Index(i))
+		val, err := e.valueToTree(mtype.Elem(), mval.Index(i))
 		if err != nil {
 			return nil, err
 		}
@@ -177,10 +383,10 @@ func valueToTreeSlice(mtype reflect.Type, mval reflect.Value) ([]*Tree, error) {
 }
 
 // Convert given marshal slice to slice of toml values
-func valueToOtherSlice(mtype reflect.Type, mval reflect.Value) (interface{}, error) {
+func (e *Encoder) valueToOtherSlice(mtype reflect.Type, mval reflect.Value) (interface{}, error) {
 	tval := make([]interface{}, mval.Len(), mval.Len())
 	for i := 0; i < mval.Len(); i++ {
-		val, err := valueToToml(mtype.Elem(), mval.Index(i))
+		val, err := e.valueToToml(mtype.Elem(), mval.Index(i))
 		if err != nil {
 			return nil, err
 		}
@@ -190,24 +396,28 @@ func valueToOtherSlice(mtype reflect.Type, mval reflect.Value) (interface{}, err
 }
 
 // Convert given marshal value to toml value
-func valueToToml(mtype reflect.Type, mval reflect.Value) (interface{}, error) {
+func (e *Encoder) valueToToml(mtype reflect.Type, mval reflect.Value) (interface{}, error) {
+	e.line++
 	if mtype.Kind() == reflect.Ptr {
-		return valueToToml(mtype.Elem(), mval.Elem())
+		return e.valueToToml(mtype.Elem(), mval.Elem())
 	}
 	switch {
 	case isCustomMarshaler(mtype):
 		return callCustomMarshaler(mval)
 	case isTree(mtype):
-		return valueToTree(mtype, mval)
+		return e.valueToTree(mtype, mval)
 	case isTreeSlice(mtype):
-		return valueToTreeSlice(mtype, mval)
+		return e.valueToTreeSlice(mtype, mval)
 	case isOtherSlice(mtype):
-		return valueToOtherSlice(mtype, mval)
+		return e.valueToOtherSlice(mtype, mval)
 	default:
 		switch mtype.Kind() {
 		case reflect.Bool:
 			return mval.Bool(), nil
 		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+			if mtype.Kind() == reflect.Int64 && mtype == reflect.TypeOf(time.Duration(1)) {
+				return fmt.Sprint(mval), nil
+			}
 			return mval.Int(), nil
 		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
 			return mval.Uint(), nil
@@ -227,17 +437,19 @@ func valueToToml(mtype reflect.Type, mval reflect.Value) (interface{}, error) {
 // Neither Unmarshaler interfaces nor UnmarshalTOML functions are supported for
 // sub-structs, and only definite types can be unmarshaled.
 func (t *Tree) Unmarshal(v interface{}) error {
-	mtype := reflect.TypeOf(v)
+	d := Decoder{tval: t, tagName: tagFieldName}
-	if mtype.Kind() != reflect.Ptr || mtype.Elem().Kind() != reflect.Struct {
+	return d.unmarshal(v)
-		return errors.New("Only a pointer to struct can be unmarshaled from TOML")
+}
-	}
 
-	sval, err := valueFromTree(mtype.Elem(), t)
+// Marshal returns the TOML encoding of Tree.
+// See Marshal() documentation for types mapping table.
+func (t *Tree) Marshal() ([]byte, error) {
+	var buf bytes.Buffer
+	_, err := t.WriteTo(&buf)
 	if err != nil {
-		return err
+		return nil, err
 	}
-	reflect.ValueOf(v).Elem().Set(sval)
+	return buf.Bytes(), nil
-	return nil
 }
 
 // Unmarshal parses the TOML-encoded data and stores the result in the value
@@ -246,6 +458,18 @@ func (t *Tree) Unmarshal(v interface{}) error {
 // sub-structs, and currently only definite types can be unmarshaled to (i.e. no
 // `interface{}`).
 //
+// The following struct annotations are supported:
+//
+//   toml:"Field" Overrides the field's name to map to.
+//   default:"foo" Provides a default value.
+//
+// For default values, only fields of the following types are supported:
+//   * string
+//   * bool
+//   * int
+//   * int64
+//   * float64
+//
 // See Marshal() documentation for types mapping table.
 func Unmarshal(data []byte, v interface{}) error {
 	t, err := LoadReader(bytes.NewReader(data))
@@ -255,55 +479,174 @@ func Unmarshal(data []byte, v interface{}) error {
 	return t.Unmarshal(v)
 }
 
-// Convert toml tree to marshal struct or map, using marshal type
+// Decoder reads and decodes TOML values from an input stream.
-func valueFromTree(mtype reflect.Type, tval *Tree) (reflect.Value, error) {
+type Decoder struct {
+	r    io.Reader
+	tval *Tree
+	encOpts
+	tagName string
+}
+
+// NewDecoder returns a new decoder that reads from r.
+func NewDecoder(r io.Reader) *Decoder {
+	return &Decoder{
+		r:       r,
+		encOpts: encOptsDefaults,
+		tagName: tagFieldName,
+	}
+}
+
+// Decode reads a TOML-encoded value from it's input
+// and unmarshals it in the value pointed at by v.
+//
+// See the documentation for Marshal for details.
+func (d *Decoder) Decode(v interface{}) error {
+	var err error
+	d.tval, err = LoadReader(d.r)
+	if err != nil {
+		return err
+	}
+	return d.unmarshal(v)
+}
+
+// SetTagName allows changing default tag "toml"
+func (d *Decoder) SetTagName(v string) *Decoder {
+	d.tagName = v
+	return d
+}
+
+func (d *Decoder) unmarshal(v interface{}) error {
+	mtype := reflect.TypeOf(v)
+	if mtype.Kind() != reflect.Ptr {
+		return errors.New("only a pointer to struct or map can be unmarshaled from TOML")
+	}
+
+	elem := mtype.Elem()
+
+	switch elem.Kind() {
+	case reflect.Struct, reflect.Map:
+	default:
+		return errors.New("only a pointer to struct or map can be unmarshaled from TOML")
+	}
+
+	vv := reflect.ValueOf(v).Elem()
+
+	sval, err := d.valueFromTree(elem, d.tval, &vv)
+	if err != nil {
+		return err
+	}
+	reflect.ValueOf(v).Elem().Set(sval)
+	return nil
+}
+
+// Convert toml tree to marshal struct or map, using marshal type. When mval1
+// is non-nil, merge fields into the given value instead of allocating a new one.
+func (d *Decoder) valueFromTree(mtype reflect.Type, tval *Tree, mval1 *reflect.Value) (reflect.Value, error) {
 	if mtype.Kind() == reflect.Ptr {
-		return unwrapPointer(mtype, tval)
+		return d.unwrapPointer(mtype, tval, mval1)
 	}
 	var mval reflect.Value
 	switch mtype.Kind() {
 	case reflect.Struct:
-		mval = reflect.New(mtype).Elem()
+		if mval1 != nil {
+			mval = *mval1
+		} else {
+			mval = reflect.New(mtype).Elem()
+		}
+
 		for i := 0; i < mtype.NumField(); i++ {
 			mtypef := mtype.Field(i)
-			opts := tomlOptions(mtypef)
+			an := annotation{tag: d.tagName}
+			opts := tomlOptions(mtypef, an)
 			if opts.include {
 				baseKey := opts.name
-				keysToTry := []string{baseKey, strings.ToLower(baseKey), strings.ToTitle(baseKey)}
+				keysToTry := []string{
+					baseKey,
+					strings.ToLower(baseKey),
+					strings.ToTitle(baseKey),
+					strings.ToLower(string(baseKey[0])) + baseKey[1:],
+				}
+
+				found := false
 				for _, key := range keysToTry {
 					exists := tval.Has(key)
 					if !exists {
 						continue
 					}
 					val := tval.Get(key)
-					mvalf, err := valueFromToml(mtypef.Type, val)
+					fval := mval.Field(i)
+					mvalf, err := d.valueFromToml(mtypef.Type, val, &fval)
 					if err != nil {
 						return mval, formatError(err, tval.GetPosition(key))
 					}
 					mval.Field(i).Set(mvalf)
+					found = true
 					break
 				}
+
+				if !found && opts.defaultValue != "" {
+					mvalf := mval.Field(i)
+					var val interface{}
+					var err error
+					switch mvalf.Kind() {
+					case reflect.Bool:
+						val, err = strconv.ParseBool(opts.defaultValue)
+						if err != nil {
+							return mval.Field(i), err
+						}
+					case reflect.Int:
+						val, err = strconv.Atoi(opts.defaultValue)
+						if err != nil {
+							return mval.Field(i), err
+						}
+					case reflect.String:
+						val = opts.defaultValue
+					case reflect.Int64:
+						val, err = strconv.ParseInt(opts.defaultValue, 10, 64)
+						if err != nil {
+							return mval.Field(i), err
+						}
+					case reflect.Float64:
+						val, err = strconv.ParseFloat(opts.defaultValue, 64)
+						if err != nil {
+							return mval.Field(i), err
+						}
+					default:
+						return mval.Field(i), fmt.Errorf("unsuported field type for default option")
+					}
+					mval.Field(i).Set(reflect.ValueOf(val))
+				}
+
+				// save the old behavior above and try to check anonymous structs
+				if !found && opts.defaultValue == "" && mtypef.Anonymous && mtypef.Type.Kind() == reflect.Struct {
+					v, err := d.valueFromTree(mtypef.Type, tval, nil)
+					if err != nil {
+						return v, err
+					}
+					mval.Field(i).Set(v)
+				}
 			}
 		}
 	case reflect.Map:
 		mval = reflect.MakeMap(mtype)
 		for _, key := range tval.Keys() {
-			val := tval.Get(key)
+			// TODO: path splits key
-			mvalf, err := valueFromToml(mtype.Elem(), val)
+			val := tval.GetPath([]string{key})
+			mvalf, err := d.valueFromToml(mtype.Elem(), val, nil)
 			if err != nil {
 				return mval, formatError(err, tval.GetPosition(key))
 			}
-			mval.SetMapIndex(reflect.ValueOf(key), mvalf)
+			mval.SetMapIndex(reflect.ValueOf(key).Convert(mtype.Key()), mvalf)
 		}
 	}
 	return mval, nil
 }
 
 // Convert toml value to marshal struct/map slice, using marshal type
-func valueFromTreeSlice(mtype reflect.Type, tval []*Tree) (reflect.Value, error) {
+func (d *Decoder) valueFromTreeSlice(mtype reflect.Type, tval []*Tree) (reflect.Value, error) {
 	mval := reflect.MakeSlice(mtype, len(tval), len(tval))
 	for i := 0; i < len(tval); i++ {
-		val, err := valueFromTree(mtype.Elem(), tval[i])
+		val, err := d.valueFromTree(mtype.Elem(), tval[i], nil)
 		if err != nil {
 			return mval, err
 		}
@@ -313,10 +656,10 @@ func valueFromTreeSlice(mtype reflect.Type, tval []*Tree) (reflect.Value, error)
 }
 
 // Convert toml value to marshal primitive slice, using marshal type
-func valueFromOtherSlice(mtype reflect.Type, tval []interface{}) (reflect.Value, error) {
+func (d *Decoder) valueFromOtherSlice(mtype reflect.Type, tval []interface{}) (reflect.Value, error) {
 	mval := reflect.MakeSlice(mtype, len(tval), len(tval))
 	for i := 0; i < len(tval); i++ {
-		val, err := valueFromToml(mtype.Elem(), tval[i])
+		val, err := d.valueFromToml(mtype.Elem(), tval[i], nil)
 		if err != nil {
 			return mval, err
 		}
@@ -325,118 +668,108 @@ func valueFromOtherSlice(mtype reflect.Type, tval []interface{}) (reflect.Value,
 	return mval, nil
 }
 
-// Convert toml value to marshal value, using marshal type
+// Convert toml value to marshal value, using marshal type. When mval1 is non-nil
-func valueFromToml(mtype reflect.Type, tval interface{}) (reflect.Value, error) {
+// and the given type is a struct value, merge fields into it.
+func (d *Decoder) valueFromToml(mtype reflect.Type, tval interface{}, mval1 *reflect.Value) (reflect.Value, error) {
 	if mtype.Kind() == reflect.Ptr {
-		return unwrapPointer(mtype, tval)
+		return d.unwrapPointer(mtype, tval, mval1)
 	}
-	switch {
+
-	case isTree(mtype):
+	switch t := tval.(type) {
-		return valueFromTree(mtype, tval.(*Tree))
+	case *Tree:
-	case isTreeSlice(mtype):
+		var mval11 *reflect.Value
-		return valueFromTreeSlice(mtype, tval.([]*Tree))
+		if mtype.Kind() == reflect.Struct {
-	case isOtherSlice(mtype):
+			mval11 = mval1
-		return valueFromOtherSlice(mtype, tval.([]interface{}))
+		}
+
+		if isTree(mtype) {
+			return d.valueFromTree(mtype, t, mval11)
+		}
+		return reflect.ValueOf(nil), fmt.Errorf("Can't convert %v(%T) to a tree", tval, tval)
+	case []*Tree:
+		if isTreeSlice(mtype) {
+			return d.valueFromTreeSlice(mtype, t)
+		}
+		return reflect.ValueOf(nil), fmt.Errorf("Can't convert %v(%T) to trees", tval, tval)
+	case []interface{}:
+		if isOtherSlice(mtype) {
+			return d.valueFromOtherSlice(mtype, t)
+		}
+		return reflect.ValueOf(nil), fmt.Errorf("Can't convert %v(%T) to a slice", tval, tval)
 	default:
 		switch mtype.Kind() {
-		case reflect.Bool:
+		case reflect.Bool, reflect.Struct:
-			val, ok := tval.(bool)
+			val := reflect.ValueOf(tval)
-			if !ok {
+			// if this passes for when mtype is reflect.Struct, tval is a time.Time
-				return reflect.ValueOf(nil), fmt.Errorf("Can't convert %v(%T) to bool", tval, tval)
+			if !val.Type().ConvertibleTo(mtype) {
+				return reflect.ValueOf(nil), fmt.Errorf("Can't convert %v(%T) to %v", tval, tval, mtype.String())
 			}
-			return reflect.ValueOf(val), nil
+
-		case reflect.Int:
+			return val.Convert(mtype), nil
-			val, ok := tval.(int64)
-			if !ok {
-				return reflect.ValueOf(nil), fmt.Errorf("Can't convert %v(%T) to int", tval, tval)
-			}
-			return reflect.ValueOf(int(val)), nil
-		case reflect.Int8:
-			val, ok := tval.(int64)
-			if !ok {
-				return reflect.ValueOf(nil), fmt.Errorf("Can't convert %v(%T) to int", tval, tval)
-			}
-			return reflect.ValueOf(int8(val)), nil
-		case reflect.Int16:
-			val, ok := tval.(int64)
-			if !ok {
-				return reflect.ValueOf(nil), fmt.Errorf("Can't convert %v(%T) to int", tval, tval)
-			}
-			return reflect.ValueOf(int16(val)), nil
-		case reflect.Int32:
-			val, ok := tval.(int64)
-			if !ok {
-				return reflect.ValueOf(nil), fmt.Errorf("Can't convert %v(%T) to int", tval, tval)
-			}
-			return reflect.ValueOf(int32(val)), nil
-		case reflect.Int64:
-			val, ok := tval.(int64)
-			if !ok {
-				return reflect.ValueOf(nil), fmt.Errorf("Can't convert %v(%T) to int", tval, tval)
-			}
-			return reflect.ValueOf(val), nil
-		case reflect.Uint:
-			val, ok := tval.(int64)
-			if !ok {
-				return reflect.ValueOf(nil), fmt.Errorf("Can't convert %v(%T) to uint", tval, tval)
-			}
-			return reflect.ValueOf(uint(val)), nil
-		case reflect.Uint8:
-			val, ok := tval.(int64)
-			if !ok {
-				return reflect.ValueOf(nil), fmt.Errorf("Can't convert %v(%T) to uint", tval, tval)
-			}
-			return reflect.ValueOf(uint8(val)), nil
-		case reflect.Uint16:
-			val, ok := tval.(int64)
-			if !ok {
-				return reflect.ValueOf(nil), fmt.Errorf("Can't convert %v(%T) to uint", tval, tval)
-			}
-			return reflect.ValueOf(uint16(val)), nil
-		case reflect.Uint32:
-			val, ok := tval.(int64)
-			if !ok {
-				return reflect.ValueOf(nil), fmt.Errorf("Can't convert %v(%T) to uint", tval, tval)
-			}
-			return reflect.ValueOf(uint32(val)), nil
-		case reflect.Uint64:
-			val, ok := tval.(int64)
-			if !ok {
-				return reflect.ValueOf(nil), fmt.Errorf("Can't convert %v(%T) to uint", tval, tval)
-			}
-			return reflect.ValueOf(uint64(val)), nil
-		case reflect.Float32:
-			val, ok := tval.(float64)
-			if !ok {
-				return reflect.ValueOf(nil), fmt.Errorf("Can't convert %v(%T) to float", tval, tval)
-			}
-			return reflect.ValueOf(float32(val)), nil
-		case reflect.Float64:
-			val, ok := tval.(float64)
-			if !ok {
-				return reflect.ValueOf(nil), fmt.Errorf("Can't convert %v(%T) to float", tval, tval)
-			}
-			return reflect.ValueOf(val), nil
 		case reflect.String:
-			val, ok := tval.(string)
+			val := reflect.ValueOf(tval)
-			if !ok {
+			// stupidly, int64 is convertible to string. So special case this.
-				return reflect.ValueOf(nil), fmt.Errorf("Can't convert %v(%T) to string", tval, tval)
+			if !val.Type().ConvertibleTo(mtype) || val.Kind() == reflect.Int64 {
+				return reflect.ValueOf(nil), fmt.Errorf("Can't convert %v(%T) to %v", tval, tval, mtype.String())
 			}
-			return reflect.ValueOf(val), nil
+
-		case reflect.Struct:
+			return val.Convert(mtype), nil
-			val, ok := tval.(time.Time)
+		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-			if !ok {
+			val := reflect.ValueOf(tval)
-				return reflect.ValueOf(nil), fmt.Errorf("Can't convert %v(%T) to time", tval, tval)
+			if mtype.Kind() == reflect.Int64 && mtype == reflect.TypeOf(time.Duration(1)) && val.Kind() == reflect.String {
+				d, err := time.ParseDuration(val.String())
+				if err != nil {
+					return reflect.ValueOf(nil), fmt.Errorf("Can't convert %v(%T) to %v. %s", tval, tval, mtype.String(), err)
+				}
+				return reflect.ValueOf(d), nil
 			}
-			return reflect.ValueOf(val), nil
+			if !val.Type().ConvertibleTo(mtype) {
+				return reflect.ValueOf(nil), fmt.Errorf("Can't convert %v(%T) to %v", tval, tval, mtype.String())
+			}
+			if reflect.Indirect(reflect.New(mtype)).OverflowInt(val.Convert(mtype).Int()) {
+				return reflect.ValueOf(nil), fmt.Errorf("%v(%T) would overflow %v", tval, tval, mtype.String())
+			}
+
+			return val.Convert(mtype), nil
+		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+			val := reflect.ValueOf(tval)
+			if !val.Type().ConvertibleTo(mtype) {
+				return reflect.ValueOf(nil), fmt.Errorf("Can't convert %v(%T) to %v", tval, tval, mtype.String())
+			}
+
+			if val.Convert(reflect.TypeOf(int(1))).Int() < 0 {
+				return reflect.ValueOf(nil), fmt.Errorf("%v(%T) is negative so does not fit in %v", tval, tval, mtype.String())
+			}
+			if reflect.Indirect(reflect.New(mtype)).OverflowUint(uint64(val.Convert(mtype).Uint())) {
+				return reflect.ValueOf(nil), fmt.Errorf("%v(%T) would overflow %v", tval, tval, mtype.String())
+			}
+
+			return val.Convert(mtype), nil
+		case reflect.Float32, reflect.Float64:
+			val := reflect.ValueOf(tval)
+			if !val.Type().ConvertibleTo(mtype) {
+				return reflect.ValueOf(nil), fmt.Errorf("Can't convert %v(%T) to %v", tval, tval, mtype.String())
+			}
+			if reflect.Indirect(reflect.New(mtype)).OverflowFloat(val.Convert(mtype).Float()) {
+				return reflect.ValueOf(nil), fmt.Errorf("%v(%T) would overflow %v", tval, tval, mtype.String())
+			}
+
+			return val.Convert(mtype), nil
 		default:
-			return reflect.ValueOf(nil), fmt.Errorf("Unmarshal can't handle %v(%v)", mtype, mtype.Kind())
+			return reflect.ValueOf(nil), fmt.Errorf("Can't convert %v(%T) to %v(%v)", tval, tval, mtype, mtype.Kind())
 		}
 	}
 }
 
-func unwrapPointer(mtype reflect.Type, tval interface{}) (reflect.Value, error) {
+func (d *Decoder) unwrapPointer(mtype reflect.Type, tval interface{}, mval1 *reflect.Value) (reflect.Value, error) {
-	val, err := valueFromToml(mtype.Elem(), tval)
+	var melem *reflect.Value
+
+	if mval1 != nil && !mval1.IsNil() && mtype.Elem().Kind() == reflect.Struct {
+		elem := mval1.Elem()
+		melem = &elem
+	}
+
+	val, err := d.valueFromToml(mtype.Elem(), tval, melem)
 	if err != nil {
 		return reflect.ValueOf(nil), err
 	}
@@ -445,10 +778,25 @@ func unwrapPointer(mtype reflect.Type, tval interface{}) (reflect.Value, error)
 	return mval, nil
 }
 
-func tomlOptions(vf reflect.StructField) tomlOpts {
+func tomlOptions(vf reflect.StructField, an annotation) tomlOpts {
-	tag := vf.Tag.Get("toml")
+	tag := vf.Tag.Get(an.tag)
 	parse := strings.Split(tag, ",")
-	result := tomlOpts{vf.Name, true, false}
+	var comment string
+	if c := vf.Tag.Get(an.comment); c != "" {
+		comment = c
+	}
+	commented, _ := strconv.ParseBool(vf.Tag.Get(an.commented))
+	multiline, _ := strconv.ParseBool(vf.Tag.Get(an.multiline))
+	defaultValue := vf.Tag.Get(tagDefault)
+	result := tomlOpts{
+		name:         vf.Name,
+		comment:      comment,
+		commented:    commented,
+		multiline:    multiline,
+		include:      true,
+		omitempty:    false,
+		defaultValue: defaultValue,
+	}
 	if parse[0] != "" {
 		if parse[0] == "-" && len(parse) == 1 {
 			result.include = false

marshal_OrderPreserve_test.toml

@@ -0,0 +1,39 @@
+title = "TOML Marshal Testing"
+
+[basic_lists]
+  floats = [12.3,45.6,78.9]
+  bools = [true,false,true]
+  dates = [1979-05-27T07:32:00Z,1980-05-27T07:32:00Z]
+  ints = [8001,8001,8002]
+  uints = [5002,5003]
+  strings = ["One","Two","Three"]
+
+[[subdocptrs]]
+  name = "Second"
+
+[basic_map]
+  one = "one"
+  two = "two"
+
+[subdoc]
+
+  [subdoc.second]
+    name = "Second"
+
+  [subdoc.first]
+    name = "First"
+
+[basic]
+  uint = 5001
+  bool = true
+  float = 123.4
+  float64 = 123.456782132399
+  int = 5000
+  string = "Bite me"
+  date = 1979-05-27T07:32:00Z
+
+[[subdoclist]]
+  name = "List.First"
+
+[[subdoclist]]
+  name = "List.Second"

marshal_test.toml

@@ -4,6 +4,7 @@ title = "TOML Marshal Testing"
   bool = true
   date = 1979-05-27T07:32:00Z
   float = 123.4
+  float64 = 123.456782132399
   int = 5000
   string = "Bite me"
   uint = 5001

parser.go

@@ -5,6 +5,7 @@ package toml
 import (
 	"errors"
 	"fmt"
+	"math"
 	"reflect"
 	"regexp"
 	"strconv"
@@ -76,8 +77,10 @@ func (p *tomlParser) parseStart() tomlParserStateFn {
 		return p.parseAssign
 	case tokenEOF:
 		return nil
+	case tokenError:
+		p.raiseError(tok, "parsing error: %s", tok.String())
 	default:
-		p.raiseError(tok, "unexpected token")
+		p.raiseError(tok, "unexpected token %s", tok.typ)
 	}
 	return nil
 }
@@ -164,6 +167,11 @@ func (p *tomlParser) parseAssign() tomlParserStateFn {
 	key := p.getToken()
 	p.assume(tokenEqual)
 
+	parsedKey, err := parseKey(key.val)
+	if err != nil {
+		p.raiseError(key, "invalid key: %s", err.Error())
+	}
+
 	value := p.parseRvalue()
 	var tableKey []string
 	if len(p.currentTable) > 0 {
@@ -172,6 +180,9 @@ func (p *tomlParser) parseAssign() tomlParserStateFn {
 		tableKey = []string{}
 	}
 
+	prefixKey := parsedKey[0 : len(parsedKey)-1]
+	tableKey = append(tableKey, prefixKey...)
+
 	// find the table to assign, looking out for arrays of tables
 	var targetNode *Tree
 	switch node := p.tree.GetPath(tableKey).(type) {
@@ -179,20 +190,19 @@ func (p *tomlParser) parseAssign() tomlParserStateFn {
 		targetNode = node[len(node)-1]
 	case *Tree:
 		targetNode = node
+	case nil:
+		// create intermediate
+		if err := p.tree.createSubTree(tableKey, key.Position); err != nil {
+			p.raiseError(key, "could not create intermediate group: %s", err)
+		}
+		targetNode = p.tree.GetPath(tableKey).(*Tree)
 	default:
 		p.raiseError(key, "Unknown table type for path: %s",
 			strings.Join(tableKey, "."))
 	}
 
 	// assign value to the found table
-	keyVals, err := parseKey(key.val)
+	keyVal := parsedKey[len(parsedKey)-1]
-	if err != nil {
-		p.raiseError(key, "%s", err)
-	}
-	if len(keyVals) != 1 {
-		p.raiseError(key, "Invalid key")
-	}
-	keyVal := keyVals[0]
 	localKey := []string{keyVal}
 	finalKey := append(tableKey, keyVal)
 	if targetNode.GetPath(localKey) != nil {
@@ -205,20 +215,32 @@ func (p *tomlParser) parseAssign() tomlParserStateFn {
 	case *Tree, []*Tree:
 		toInsert = value
 	default:
-		toInsert = &tomlValue{value, key.Position}
+		toInsert = &tomlValue{value: value, position: key.Position}
 	}
 	targetNode.values[keyVal] = toInsert
 	return p.parseStart
 }
 
 var numberUnderscoreInvalidRegexp *regexp.Regexp
+var hexNumberUnderscoreInvalidRegexp *regexp.Regexp
 
-func cleanupNumberToken(value string) (string, error) {
+func numberContainsInvalidUnderscore(value string) error {
 	if numberUnderscoreInvalidRegexp.MatchString(value) {
-		return "", errors.New("invalid use of _ in number")
+		return errors.New("invalid use of _ in number")
 	}
+	return nil
+}
+
+func hexNumberContainsInvalidUnderscore(value string) error {
+	if hexNumberUnderscoreInvalidRegexp.MatchString(value) {
+		return errors.New("invalid use of _ in hex number")
+	}
+	return nil
+}
+
+func cleanupNumberToken(value string) string {
 	cleanedVal := strings.Replace(value, "_", "", -1)
-	return cleanedVal, nil
+	return cleanedVal
 }
 
 func (p *tomlParser) parseRvalue() interface{} {
@@ -234,28 +256,68 @@ func (p *tomlParser) parseRvalue() interface{} {
 		return true
 	case tokenFalse:
 		return false
-	case tokenInteger:
+	case tokenInf:
-		cleanedVal, err := cleanupNumberToken(tok.val)
+		if tok.val[0] == '-' {
-		if err != nil {
+			return math.Inf(-1)
-			p.raiseError(tok, "%s", err)
+		}
+		return math.Inf(1)
+	case tokenNan:
+		return math.NaN()
+	case tokenInteger:
+		cleanedVal := cleanupNumberToken(tok.val)
+		var err error
+		var val int64
+		if len(cleanedVal) >= 3 && cleanedVal[0] == '0' {
+			switch cleanedVal[1] {
+			case 'x':
+				err = hexNumberContainsInvalidUnderscore(tok.val)
+				if err != nil {
+					p.raiseError(tok, "%s", err)
+				}
+				val, err = strconv.ParseInt(cleanedVal[2:], 16, 64)
+			case 'o':
+				err = numberContainsInvalidUnderscore(tok.val)
+				if err != nil {
+					p.raiseError(tok, "%s", err)
+				}
+				val, err = strconv.ParseInt(cleanedVal[2:], 8, 64)
+			case 'b':
+				err = numberContainsInvalidUnderscore(tok.val)
+				if err != nil {
+					p.raiseError(tok, "%s", err)
+				}
+				val, err = strconv.ParseInt(cleanedVal[2:], 2, 64)
+			default:
+				panic("invalid base") // the lexer should catch this first
+			}
+		} else {
+			err = numberContainsInvalidUnderscore(tok.val)
+			if err != nil {
+				p.raiseError(tok, "%s", err)
+			}
+			val, err = strconv.ParseInt(cleanedVal, 10, 64)
 		}
-		val, err := strconv.ParseInt(cleanedVal, 10, 64)
 		if err != nil {
 			p.raiseError(tok, "%s", err)
 		}
 		return val
 	case tokenFloat:
-		cleanedVal, err := cleanupNumberToken(tok.val)
+		err := numberContainsInvalidUnderscore(tok.val)
 		if err != nil {
 			p.raiseError(tok, "%s", err)
 		}
+		cleanedVal := cleanupNumberToken(tok.val)
 		val, err := strconv.ParseFloat(cleanedVal, 64)
 		if err != nil {
 			p.raiseError(tok, "%s", err)
 		}
 		return val
 	case tokenDate:
-		val, err := time.ParseInLocation(time.RFC3339Nano, tok.val, time.UTC)
+		layout := time.RFC3339Nano
+		if !strings.Contains(tok.val, "T") {
+			layout = strings.Replace(layout, "T", " ", 1)
+		}
+		val, err := time.ParseInLocation(layout, tok.val, time.UTC)
 		if err != nil {
 			p.raiseError(tok, "%s", err)
 		}
@@ -292,7 +354,7 @@ Loop:
 		case tokenRightCurlyBrace:
 			p.getToken()
 			break Loop
-		case tokenKey:
+		case tokenKey, tokenInteger, tokenString:
 			if !tokenIsComma(previous) && previous != nil {
 				p.raiseError(follow, "comma expected between fields in inline table")
 			}
@@ -309,7 +371,7 @@ Loop:
 			}
 			p.getToken()
 		default:
-			p.raiseError(follow, "unexpected token type in inline table: %s", follow.typ.String())
+			p.raiseError(follow, "unexpected token type in inline table: %s", follow.String())
 		}
 		previous = follow
 	}
@@ -379,5 +441,6 @@ func parseToml(flow []token) *Tree {
 }
 
 func init() {
-	numberUnderscoreInvalidRegexp = regexp.MustCompile(`([^\d]_|_[^\d]|_$|^_)`)
+	numberUnderscoreInvalidRegexp = regexp.MustCompile(`([^\d]_|_[^\d])|_$|^_`)
+	hexNumberUnderscoreInvalidRegexp = regexp.MustCompile(`(^0x_)|([^\da-f]_|_[^\da-f])|_$|^_`)
 }

parser_test.go

@@ -2,6 +2,7 @@ package toml
 
 import (
 	"fmt"
+	"math"
 	"reflect"
 	"testing"
 	"time"
@@ -72,6 +73,17 @@ func TestNumberInKey(t *testing.T) {
 	})
 }
 
+func TestIncorrectKeyExtraSquareBracket(t *testing.T) {
+	_, err := Load(`[a]b]
+zyx = 42`)
+	if err == nil {
+		t.Error("Error should have been returned.")
+	}
+	if err.Error() != "(1, 4): parsing error: keys cannot contain ] character" {
+		t.Error("Bad error message:", err.Error())
+	}
+}
+
 func TestSimpleNumbers(t *testing.T) {
 	tree, err := Load("a = +42\nb = -21\nc = +4.2\nd = -2.1")
 	assertTree(t, tree, err, map[string]interface{}{
@@ -82,6 +94,78 @@ func TestSimpleNumbers(t *testing.T) {
 	})
 }
 
+func TestSpecialFloats(t *testing.T) {
+	tree, err := Load(`
+normalinf = inf
+plusinf = +inf
+minusinf = -inf
+normalnan = nan
+plusnan = +nan
+minusnan = -nan
+`)
+	assertTree(t, tree, err, map[string]interface{}{
+		"normalinf": math.Inf(1),
+		"plusinf":   math.Inf(1),
+		"minusinf":  math.Inf(-1),
+		"normalnan": math.NaN(),
+		"plusnan":   math.NaN(),
+		"minusnan":  math.NaN(),
+	})
+}
+
+func TestHexIntegers(t *testing.T) {
+	tree, err := Load(`a = 0xDEADBEEF`)
+	assertTree(t, tree, err, map[string]interface{}{"a": int64(3735928559)})
+
+	tree, err = Load(`a = 0xdeadbeef`)
+	assertTree(t, tree, err, map[string]interface{}{"a": int64(3735928559)})
+
+	tree, err = Load(`a = 0xdead_beef`)
+	assertTree(t, tree, err, map[string]interface{}{"a": int64(3735928559)})
+
+	_, err = Load(`a = 0x_1`)
+	if err.Error() != "(1, 5): invalid use of _ in hex number" {
+		t.Error("Bad error message:", err.Error())
+	}
+}
+
+func TestOctIntegers(t *testing.T) {
+	tree, err := Load(`a = 0o01234567`)
+	assertTree(t, tree, err, map[string]interface{}{"a": int64(342391)})
+
+	tree, err = Load(`a = 0o755`)
+	assertTree(t, tree, err, map[string]interface{}{"a": int64(493)})
+
+	_, err = Load(`a = 0o_1`)
+	if err.Error() != "(1, 5): invalid use of _ in number" {
+		t.Error("Bad error message:", err.Error())
+	}
+}
+
+func TestBinIntegers(t *testing.T) {
+	tree, err := Load(`a = 0b11010110`)
+	assertTree(t, tree, err, map[string]interface{}{"a": int64(214)})
+
+	_, err = Load(`a = 0b_1`)
+	if err.Error() != "(1, 5): invalid use of _ in number" {
+		t.Error("Bad error message:", err.Error())
+	}
+}
+
+func TestBadIntegerBase(t *testing.T) {
+	_, err := Load(`a = 0k1`)
+	if err.Error() != "(1, 5): unknown number base: k. possible options are x (hex) o (octal) b (binary)" {
+		t.Error("Error should have been returned.")
+	}
+}
+
+func TestIntegerNoDigit(t *testing.T) {
+	_, err := Load(`a = 0b`)
+	if err.Error() != "(1, 5): number needs at least one digit" {
+		t.Error("Bad error message:", err.Error())
+	}
+}
+
 func TestNumbersWithUnderscores(t *testing.T) {
 	tree, err := Load("a = 1_000")
 	assertTree(t, tree, err, map[string]interface{}{
@@ -141,6 +225,13 @@ func TestDateNano(t *testing.T) {
 	})
 }
 
+func TestDateSpaceDelimiter(t *testing.T) {
+	tree, err := Load("odt4 = 1979-05-27 07:32:00Z")
+	assertTree(t, tree, err, map[string]interface{}{
+		"odt4": time.Date(1979, time.May, 27, 7, 32, 0, 0, time.UTC),
+	})
+}
+
 func TestSimpleString(t *testing.T) {
 	tree, err := Load("a = \"hello world\"")
 	assertTree(t, tree, err, map[string]interface{}{
@@ -155,6 +246,36 @@ func TestSpaceKey(t *testing.T) {
 	})
 }
 
+func TestDoubleQuotedKey(t *testing.T) {
+	tree, err := Load(`
+	"key"        = "a"
+	"\t"         = "b"
+	"\U0001F914" = "c"
+	"\u2764"     = "d"
+	`)
+	assertTree(t, tree, err, map[string]interface{}{
+		"key":        "a",
+		"\t":         "b",
+		"\U0001F914": "c",
+		"\u2764":     "d",
+	})
+}
+
+func TestSingleQuotedKey(t *testing.T) {
+	tree, err := Load(`
+	'key'        = "a"
+	'\t'         = "b"
+	'\U0001F914' = "c"
+	'\u2764'     = "d"
+	`)
+	assertTree(t, tree, err, map[string]interface{}{
+		`key`:        "a",
+		`\t`:         "b",
+		`\U0001F914`: "c",
+		`\u2764`:     "d",
+	})
+}
+
 func TestStringEscapables(t *testing.T) {
 	tree, err := Load("a = \"a \\n b\"")
 	assertTree(t, tree, err, map[string]interface{}{
@@ -467,7 +588,7 @@ func TestDuplicateKeys(t *testing.T) {
 
 func TestEmptyIntermediateTable(t *testing.T) {
 	_, err := Load("[foo..bar]")
-	if err.Error() != "(1, 2): invalid table array key: empty table key" {
+	if err.Error() != "(1, 2): invalid table array key: expecting key part after dot" {
 		t.Error("Bad error message:", err.Error())
 	}
 }
@@ -642,7 +763,7 @@ func TestTomlValueStringRepresentation(t *testing.T) {
 		{int64(12345), "12345"},
 		{uint64(50), "50"},
 		{float64(123.45), "123.45"},
-		{bool(true), "true"},
+		{true, "true"},
 		{"hello world", "\"hello world\""},
 		{"\b\t\n\f\r\"\\", "\"\\b\\t\\n\\f\\r\\\"\\\\\""},
 		{"\x05", "\"\\u0005\""},
@@ -652,7 +773,7 @@ func TestTomlValueStringRepresentation(t *testing.T) {
 			"[\"gamma\",\"delta\"]"},
 		{nil, ""},
 	} {
-		result, err := tomlValueStringRepresentation(item.Value)
+		result, err := tomlValueStringRepresentation(item.Value, "", false)
 		if err != nil {
 			t.Errorf("Test %d - unexpected error: %s", idx, err)
 		}
@@ -783,3 +904,43 @@ func TestInvalidFloatParsing(t *testing.T) {
 		t.Error("Bad error message:", err.Error())
 	}
 }
+
+func TestMapKeyIsNum(t *testing.T) {
+	_, err := Load("table={2018=1,2019=2}")
+	if err != nil {
+		t.Error("should be passed")
+	}
+	_, err = Load(`table={"2018"=1,"2019"=2}`)
+	if err != nil {
+		t.Error("should be passed")
+	}
+}
+
+func TestDottedKeys(t *testing.T) {
+	tree, err := Load(`
+name = "Orange"
+physical.color = "orange"
+physical.shape = "round"
+site."google.com" = true`)
+
+	assertTree(t, tree, err, map[string]interface{}{
+		"name": "Orange",
+		"physical": map[string]interface{}{
+			"color": "orange",
+			"shape": "round",
+		},
+		"site": map[string]interface{}{
+			"google.com": true,
+		},
+	})
+}
+
+func TestInvalidDottedKeyEmptyGroup(t *testing.T) {
+	_, err := Load(`a..b = true`)
+	if err == nil {
+		t.Fatal("should return an error")
+	}
+	if err.Error() != "(1, 1): invalid key: expecting key part after dot" {
+		t.Fatalf("invalid error message: %s", err)
+	}
+}

query/doc.go

@@ -139,7 +139,7 @@
 // Compiled Queries
 //
 // Queries may be executed directly on a Tree object, or compiled ahead
-// of time and executed discretely.  The former is more convienent, but has the
+// of time and executed discretely.  The former is more convenient, but has the
 // penalty of having to recompile the query expression each time.
 //
 //   // basic query

query/parser_test.go

@@ -2,12 +2,13 @@ package query
 
 import (
 	"fmt"
-	"github.com/pelletier/go-toml"
 	"io/ioutil"
 	"sort"
 	"strings"
 	"testing"
 	"time"
+
+	"github.com/pelletier/go-toml"
 )
 
 type queryTestNode struct {
@@ -406,8 +407,7 @@ func TestQueryFilterFn(t *testing.T) {
 
 	assertQueryPositions(t, string(buff),
 		"$..[?(float)]",
-		[]interface{}{
+		[]interface{}{ // no float values in document
-		// no float values in document
 		})
 
 	tv, _ := time.Parse(time.RFC3339, "1979-05-27T07:32:00Z")

test.sh

@@ -1,90 +0,0 @@
-#!/bin/bash
-# fail out of the script if anything here fails
-set -e
-
-# set the path to the present working directory
-export GOPATH=`pwd`
-
-function git_clone() {
-  path=$1
-  branch=$2
-  version=$3
-  if [ ! -d "src/$path" ]; then
-    mkdir -p src/$path
-    git clone https://$path.git src/$path
-  fi
-  pushd src/$path
-  git checkout "$branch"
-  git reset --hard "$version"
-  popd
-}
-
-# Remove potential previous runs
-rm -rf src test_program_bin toml-test
-
-# Run go vet
-go vet ./...
-
-go get github.com/pelletier/go-buffruneio
-go get github.com/davecgh/go-spew/spew
-go get gopkg.in/yaml.v2
-go get github.com/BurntSushi/toml
-
-# get code for BurntSushi TOML validation
-# pinning all to 'HEAD' for version 0.3.x work (TODO: pin to commit hash when tests stabilize)
-git_clone github.com/BurntSushi/toml master HEAD
-git_clone github.com/BurntSushi/toml-test master HEAD #was: 0.2.0 HEAD
-
-# build the BurntSushi test application
-go build -o toml-test github.com/BurntSushi/toml-test
-
-# vendorize the current lib for testing
-# NOTE: this basically mocks an install without having to go back out to github for code
-mkdir -p src/github.com/pelletier/go-toml/cmd
-mkdir -p src/github.com/pelletier/go-toml/query
-cp *.go *.toml src/github.com/pelletier/go-toml
-cp -R cmd/* src/github.com/pelletier/go-toml/cmd
-cp -R query/* src/github.com/pelletier/go-toml/query
-go build -o test_program_bin src/github.com/pelletier/go-toml/cmd/test_program.go
-
-# Run basic unit tests
-go test github.com/pelletier/go-toml -covermode=count -coverprofile=coverage.out
-go test github.com/pelletier/go-toml/cmd/tomljson
-go test github.com/pelletier/go-toml/query
-
-# run the entire BurntSushi test suite
-if [[ $# -eq 0 ]] ; then
-  echo "Running all BurntSushi tests"
-  ./toml-test ./test_program_bin | tee test_out
-else
-  # run a specific test
-  test=$1
-  test_path='src/github.com/BurntSushi/toml-test/tests'
-  valid_test="$test_path/valid/$test"
-  invalid_test="$test_path/invalid/$test"
-
-  if [ -e "$valid_test.toml" ]; then
-    echo "Valid Test TOML for $test:"
-    echo "===="
-    cat "$valid_test.toml"
-
-    echo "Valid Test JSON for $test:"
-    echo "===="
-    cat "$valid_test.json"
-
-    echo "Go-TOML Output for $test:"
-    echo "===="
-    cat "$valid_test.toml" | ./test_program_bin
-  fi
-
-  if [ -e "$invalid_test.toml" ]; then
-    echo "Invalid Test TOML for $test:"
-    echo "===="
-    cat "$invalid_test.toml"
-
-    echo "Go-TOML Output for $test:"
-    echo "===="
-    echo "go-toml Output:"
-    cat "$invalid_test.toml" | ./test_program_bin
-  fi
-fi

token.go

@@ -23,6 +23,8 @@ const (
 	tokenTrue
 	tokenFalse
 	tokenFloat
+	tokenInf
+	tokenNan
 	tokenEqual
 	tokenLeftBracket
 	tokenRightBracket
@@ -55,6 +57,8 @@ var tokenTypeNames = []string{
 	"True",
 	"False",
 	"Float",
+	"Inf",
+	"NaN",
 	"=",
 	"[",
 	"]",

toml.go

@@ -11,20 +11,29 @@ import (
 )
 
 type tomlValue struct {
-	value    interface{} // string, int64, uint64, float64, bool, time.Time, [] of any of this list
+	value     interface{} // string, int64, uint64, float64, bool, time.Time, [] of any of this list
-	position Position
+	comment   string
+	commented bool
+	multiline bool
+	position  Position
 }
 
 // Tree is the result of the parsing of a TOML file.
 type Tree struct {
-	values   map[string]interface{} // string -> *tomlValue, *Tree, []*Tree
+	values    map[string]interface{} // string -> *tomlValue, *Tree, []*Tree
-	position Position
+	comment   string
+	commented bool
+	position  Position
 }
 
 func newTree() *Tree {
+	return newTreeWithPosition(Position{})
+}
+
+func newTreeWithPosition(pos Position) *Tree {
 	return &Tree{
 		values:   make(map[string]interface{}),
-		position: Position{},
+		position: pos,
 	}
 }
 
@@ -67,18 +76,15 @@ func (t *Tree) Keys() []string {
 }
 
 // Get the value at key in the Tree.
-// Key is a dot-separated path (e.g. a.b.c).
+// Key is a dot-separated path (e.g. a.b.c) without single/double quoted strings.
+// If you need to retrieve non-bare keys, use GetPath.
 // Returns nil if the path does not exist in the tree.
 // If keys is of length zero, the current tree is returned.
 func (t *Tree) Get(key string) interface{} {
 	if key == "" {
 		return t
 	}
-	comps, err := parseKey(key)
+	return t.GetPath(strings.Split(key, "."))
-	if err != nil {
-		return nil
-	}
-	return t.GetPath(comps)
 }
 
 // GetPath returns the element in the tree indicated by 'keys'.
@@ -174,22 +180,28 @@ func (t *Tree) GetDefault(key string, def interface{}) interface{} {
 	return val
 }
 
-// Set an element in the tree.
+// SetOptions arguments are supplied to the SetWithOptions and SetPathWithOptions functions to modify marshalling behaviour.
-// Key is a dot-separated path (e.g. a.b.c).
+// The default values within the struct are valid default options.
-// Creates all necessary intermediate trees, if needed.
+type SetOptions struct {
-func (t *Tree) Set(key string, value interface{}) {
+	Comment   string
-	t.SetPath(strings.Split(key, "."), value)
+	Commented bool
+	Multiline bool
 }
 
-// SetPath sets an element in the tree.
+// SetWithOptions is the same as Set, but allows you to provide formatting
-// Keys is an array of path elements (e.g. {"a","b","c"}).
+// instructions to the key, that will be used by Marshal().
-// Creates all necessary intermediate trees, if needed.
+func (t *Tree) SetWithOptions(key string, opts SetOptions, value interface{}) {
-func (t *Tree) SetPath(keys []string, value interface{}) {
+	t.SetPathWithOptions(strings.Split(key, "."), opts, value)
+}
+
+// SetPathWithOptions is the same as SetPath, but allows you to provide
+// formatting instructions to the key, that will be reused by Marshal().
+func (t *Tree) SetPathWithOptions(keys []string, opts SetOptions, value interface{}) {
 	subtree := t
-	for _, intermediateKey := range keys[:len(keys)-1] {
+	for i, intermediateKey := range keys[:len(keys)-1] {
 		nextTree, exists := subtree.values[intermediateKey]
 		if !exists {
-			nextTree = newTree()
+			nextTree = newTreeWithPosition(Position{Line: t.position.Line + i, Col: t.position.Col})
 			subtree.values[intermediateKey] = nextTree // add new element here
 		}
 		switch node := nextTree.(type) {
@@ -199,7 +211,7 @@ func (t *Tree) SetPath(keys []string, value interface{}) {
 			// go to most recent element
 			if len(node) == 0 {
 				// create element if it does not exist
-				subtree.values[intermediateKey] = append(node, newTree())
+				subtree.values[intermediateKey] = append(node, newTreeWithPosition(Position{Line: t.position.Line + i, Col: t.position.Col}))
 			}
 			subtree = node[len(node)-1]
 		}
@@ -207,20 +219,80 @@ func (t *Tree) SetPath(keys []string, value interface{}) {
 
 	var toInsert interface{}
 
-	switch value.(type) {
+	switch v := value.(type) {
 	case *Tree:
+		v.comment = opts.Comment
 		toInsert = value
 	case []*Tree:
 		toInsert = value
 	case *tomlValue:
-		toInsert = value
+		v.comment = opts.Comment
+		toInsert = v
 	default:
-		toInsert = &tomlValue{value: value}
+		toInsert = &tomlValue{value: value,
+			comment:   opts.Comment,
+			commented: opts.Commented,
+			multiline: opts.Multiline,
+			position:  Position{Line: subtree.position.Line + len(subtree.values) + 1, Col: subtree.position.Col}}
 	}
 
 	subtree.values[keys[len(keys)-1]] = toInsert
 }
 
+// Set an element in the tree.
+// Key is a dot-separated path (e.g. a.b.c).
+// Creates all necessary intermediate trees, if needed.
+func (t *Tree) Set(key string, value interface{}) {
+	t.SetWithComment(key, "", false, value)
+}
+
+// SetWithComment is the same as Set, but allows you to provide comment
+// information to the key, that will be reused by Marshal().
+func (t *Tree) SetWithComment(key string, comment string, commented bool, value interface{}) {
+	t.SetPathWithComment(strings.Split(key, "."), comment, commented, value)
+}
+
+// SetPath sets an element in the tree.
+// Keys is an array of path elements (e.g. {"a","b","c"}).
+// Creates all necessary intermediate trees, if needed.
+func (t *Tree) SetPath(keys []string, value interface{}) {
+	t.SetPathWithComment(keys, "", false, value)
+}
+
+// SetPathWithComment is the same as SetPath, but allows you to provide comment
+// information to the key, that will be reused by Marshal().
+func (t *Tree) SetPathWithComment(keys []string, comment string, commented bool, value interface{}) {
+	t.SetPathWithOptions(keys, SetOptions{Comment: comment, Commented: commented}, value)
+}
+
+// Delete removes a key from the tree.
+// Key is a dot-separated path (e.g. a.b.c).
+func (t *Tree) Delete(key string) error {
+	keys, err := parseKey(key)
+	if err != nil {
+		return err
+	}
+	return t.DeletePath(keys)
+}
+
+// DeletePath removes a key from the tree.
+// Keys is an array of path elements (e.g. {"a","b","c"}).
+func (t *Tree) DeletePath(keys []string) error {
+	keyLen := len(keys)
+	if keyLen == 1 {
+		delete(t.values, keys[0])
+		return nil
+	}
+	tree := t.GetPath(keys[:keyLen-1])
+	item := keys[keyLen-1]
+	switch node := tree.(type) {
+	case *Tree:
+		delete(node.values, item)
+		return nil
+	}
+	return errors.New("no such key to delete")
+}
+
 // createSubTree takes a tree and a key and create the necessary intermediate
 // subtrees to create a subtree at that point. In-place.
 //
@@ -230,10 +302,10 @@ func (t *Tree) SetPath(keys []string, value interface{}) {
 // Returns nil on success, error object on failure
 func (t *Tree) createSubTree(keys []string, pos Position) error {
 	subtree := t
-	for _, intermediateKey := range keys {
+	for i, intermediateKey := range keys {
 		nextTree, exists := subtree.values[intermediateKey]
 		if !exists {
-			tree := newTree()
+			tree := newTreeWithPosition(Position{Line: t.position.Line + i, Col: t.position.Col})
 			tree.position = pos
 			subtree.values[intermediateKey] = tree
 			nextTree = tree
@@ -262,10 +334,39 @@ func LoadBytes(b []byte) (tree *Tree, err error) {
 			err = errors.New(r.(string))
 		}
 	}()
+
+	if len(b) >= 4 && (hasUTF32BigEndianBOM4(b) || hasUTF32LittleEndianBOM4(b)) {
+		b = b[4:]
+	} else if len(b) >= 3 && hasUTF8BOM3(b) {
+		b = b[3:]
+	} else if len(b) >= 2 && (hasUTF16BigEndianBOM2(b) || hasUTF16LittleEndianBOM2(b)) {
+		b = b[2:]
+	}
+
 	tree = parseToml(lexToml(b))
 	return
 }
 
+func hasUTF16BigEndianBOM2(b []byte) bool {
+	return b[0] == 0xFE && b[1] == 0xFF
+}
+
+func hasUTF16LittleEndianBOM2(b []byte) bool {
+	return b[0] == 0xFF && b[1] == 0xFE
+}
+
+func hasUTF8BOM3(b []byte) bool {
+	return b[0] == 0xEF && b[1] == 0xBB && b[2] == 0xBF
+}
+
+func hasUTF32BigEndianBOM4(b []byte) bool {
+	return b[0] == 0x00 && b[1] == 0x00 && b[2] == 0xFE && b[3] == 0xFF
+}
+
+func hasUTF32LittleEndianBOM4(b []byte) bool {
+	return b[0] == 0xFF && b[1] == 0xFE && b[2] == 0x00 && b[3] == 0x00
+}
+
 // LoadReader creates a Tree from any io.Reader.
 func LoadReader(reader io.Reader) (tree *Tree, err error) {
 	inputBytes, err := ioutil.ReadAll(reader)

toml_test.go

@@ -69,6 +69,60 @@ func TestTomlHasPath(t *testing.T) {
 	}
 }
 
+func TestTomlDelete(t *testing.T) {
+	tree, _ := Load(`
+        key = "value"
+    `)
+	err := tree.Delete("key")
+	if err != nil {
+		t.Errorf("Delete - unexpected error while deleting key: %s", err.Error())
+	}
+
+	if tree.Get("key") != nil {
+		t.Errorf("Delete should have removed key but did not.")
+	}
+
+}
+
+func TestTomlDeleteUnparsableKey(t *testing.T) {
+	tree, _ := Load(`
+        key = "value"
+    `)
+	err := tree.Delete(".")
+	if err == nil {
+		t.Errorf("Delete should error")
+	}
+}
+
+func TestTomlDeleteNestedKey(t *testing.T) {
+	tree, _ := Load(`
+		[foo]
+        [foo.bar]
+        key = "value"
+    `)
+	err := tree.Delete("foo.bar.key")
+	if err != nil {
+		t.Errorf("Error while deleting nested key: %s", err.Error())
+	}
+
+	if tree.Get("key") != nil {
+		t.Errorf("Delete should have removed nested key but did not.")
+	}
+
+}
+
+func TestTomlDeleteNonexistentNestedKey(t *testing.T) {
+	tree, _ := Load(`
+		[foo]
+        [foo.bar]
+        key = "value"
+    `)
+	err := tree.Delete("foo.not.there.key")
+	if err == nil {
+		t.Errorf("Delete should have thrown an error trying to delete key in nonexistent tree")
+	}
+}
+
 func TestTomlGetPath(t *testing.T) {
 	node := newTree()
 	//TODO: set other node data
@@ -104,3 +158,23 @@ func TestTomlFromMap(t *testing.T) {
 		t.Fatal("hello should be 42, not", tree.Get("hello"))
 	}
 }
+
+func TestLoadBytesBOM(t *testing.T) {
+	payloads := [][]byte{
+		[]byte("\xFE\xFFhello=1"),
+		[]byte("\xFF\xFEhello=1"),
+		[]byte("\xEF\xBB\xBFhello=1"),
+		[]byte("\x00\x00\xFE\xFFhello=1"),
+		[]byte("\xFF\xFE\x00\x00hello=1"),
+	}
+	for _, data := range payloads {
+		tree, err := LoadBytes(data)
+		if err != nil {
+			t.Fatal("unexpected error:", err, "for:", data)
+		}
+		v := tree.Get("hello")
+		if v != int64(1) {
+			t.Fatal("hello should be 1, not", v)
+		}
+	}
+}

toml_testgen_support_test.go

@@ -0,0 +1,119 @@
+// This is a support file for toml_testgen_test.go
+package toml
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"reflect"
+	"testing"
+	"time"
+
+	"github.com/davecgh/go-spew/spew"
+)
+
+func testgenInvalid(t *testing.T, input string) {
+	t.Logf("Input TOML:\n%s", input)
+	tree, err := Load(input)
+	if err != nil {
+		return
+	}
+
+	typedTree := testgenTranslate(*tree)
+
+	buf := new(bytes.Buffer)
+	if err := json.NewEncoder(buf).Encode(typedTree); err != nil {
+		return
+	}
+
+	t.Fatalf("test did not fail. resulting tree:\n%s", buf.String())
+}
+
+func testgenValid(t *testing.T, input string, jsonRef string) {
+	t.Logf("Input TOML:\n%s", input)
+	tree, err := Load(input)
+	if err != nil {
+		t.Fatalf("failed parsing toml: %s", err)
+	}
+
+	typedTree := testgenTranslate(*tree)
+
+	buf := new(bytes.Buffer)
+	if err := json.NewEncoder(buf).Encode(typedTree); err != nil {
+		t.Fatalf("failed translating to JSON: %s", err)
+	}
+
+	var jsonTest interface{}
+	if err := json.NewDecoder(buf).Decode(&jsonTest); err != nil {
+		t.Logf("translated JSON:\n%s", buf.String())
+		t.Fatalf("failed decoding translated JSON: %s", err)
+	}
+
+	var jsonExpected interface{}
+	if err := json.NewDecoder(bytes.NewBufferString(jsonRef)).Decode(&jsonExpected); err != nil {
+		t.Logf("reference JSON:\n%s", jsonRef)
+		t.Fatalf("failed decoding reference JSON: %s", err)
+	}
+
+	if !reflect.DeepEqual(jsonExpected, jsonTest) {
+		t.Logf("Diff:\n%s", spew.Sdump(jsonExpected, jsonTest))
+		t.Fatal("parsed TOML tree is different than expected structure")
+	}
+}
+
+func testgenTranslate(tomlData interface{}) interface{} {
+	switch orig := tomlData.(type) {
+	case map[string]interface{}:
+		typed := make(map[string]interface{}, len(orig))
+		for k, v := range orig {
+			typed[k] = testgenTranslate(v)
+		}
+		return typed
+	case *Tree:
+		return testgenTranslate(*orig)
+	case Tree:
+		keys := orig.Keys()
+		typed := make(map[string]interface{}, len(keys))
+		for _, k := range keys {
+			typed[k] = testgenTranslate(orig.GetPath([]string{k}))
+		}
+		return typed
+	case []*Tree:
+		typed := make([]map[string]interface{}, len(orig))
+		for i, v := range orig {
+			typed[i] = testgenTranslate(v).(map[string]interface{})
+		}
+		return typed
+	case []map[string]interface{}:
+		typed := make([]map[string]interface{}, len(orig))
+		for i, v := range orig {
+			typed[i] = testgenTranslate(v).(map[string]interface{})
+		}
+		return typed
+	case []interface{}:
+		typed := make([]interface{}, len(orig))
+		for i, v := range orig {
+			typed[i] = testgenTranslate(v)
+		}
+		return testgenTag("array", typed)
+	case time.Time:
+		return testgenTag("datetime", orig.Format("2006-01-02T15:04:05Z"))
+	case bool:
+		return testgenTag("bool", fmt.Sprintf("%v", orig))
+	case int64:
+		return testgenTag("integer", fmt.Sprintf("%d", orig))
+	case float64:
+		return testgenTag("float", fmt.Sprintf("%v", orig))
+	case string:
+		return testgenTag("string", orig)
+	}
+
+	panic(fmt.Sprintf("Unknown type: %T", tomlData))
+}
+
+func testgenTag(typeName string, data interface{}) map[string]interface{} {
+	return map[string]interface{}{
+		"type":  typeName,
+		"value": data,
+	}
+}

toml_testgen_test.go

@@ -0,0 +1,943 @@
+// Generated by tomltestgen for toml-test ref 39e37e6 on 2019-03-19T23:58:45-07:00
+package toml
+
+import (
+	"testing"
+)
+
+func TestInvalidArrayMixedTypesArraysAndInts(t *testing.T) {
+	input := `arrays-and-ints =  [1, ["Arrays are not integers."]]`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidArrayMixedTypesIntsAndFloats(t *testing.T) {
+	input := `ints-and-floats = [1, 1.1]`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidArrayMixedTypesStringsAndInts(t *testing.T) {
+	input := `strings-and-ints = ["hi", 42]`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidDatetimeMalformedNoLeads(t *testing.T) {
+	input := `no-leads = 1987-7-05T17:45:00Z`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidDatetimeMalformedNoSecs(t *testing.T) {
+	input := `no-secs = 1987-07-05T17:45Z`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidDatetimeMalformedNoT(t *testing.T) {
+	input := `no-t = 1987-07-0517:45:00Z`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidDatetimeMalformedWithMilli(t *testing.T) {
+	input := `with-milli = 1987-07-5T17:45:00.12Z`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidDuplicateKeyTable(t *testing.T) {
+	input := `[fruit]
+type = "apple"
+
+[fruit.type]
+apple = "yes"`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidDuplicateKeys(t *testing.T) {
+	input := `dupe = false
+dupe = true`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidDuplicateTables(t *testing.T) {
+	input := `[a]
+[a]`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidEmptyImplicitTable(t *testing.T) {
+	input := `[naughty..naughty]`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidEmptyTable(t *testing.T) {
+	input := `[]`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidFloatNoLeadingZero(t *testing.T) {
+	input := `answer = .12345
+neganswer = -.12345`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidFloatNoTrailingDigits(t *testing.T) {
+	input := `answer = 1.
+neganswer = -1.`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidKeyEmpty(t *testing.T) {
+	input := ` = 1`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidKeyHash(t *testing.T) {
+	input := `a# = 1`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidKeyNewline(t *testing.T) {
+	input := `a
+= 1`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidKeyOpenBracket(t *testing.T) {
+	input := `[abc = 1`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidKeySingleOpenBracket(t *testing.T) {
+	input := `[`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidKeySpace(t *testing.T) {
+	input := `a b = 1`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidKeyStartBracket(t *testing.T) {
+	input := `[a]
+[xyz = 5
+[b]`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidKeyTwoEquals(t *testing.T) {
+	input := `key= = 1`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidStringBadByteEscape(t *testing.T) {
+	input := `naughty = "\xAg"`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidStringBadEscape(t *testing.T) {
+	input := `invalid-escape = "This string has a bad \a escape character."`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidStringByteEscapes(t *testing.T) {
+	input := `answer = "\x33"`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidStringNoClose(t *testing.T) {
+	input := `no-ending-quote = "One time, at band camp`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidTableArrayImplicit(t *testing.T) {
+	input := "# This test is a bit tricky. It should fail because the first use of\n" +
+		"# `[[albums.songs]]` without first declaring `albums` implies that `albums`\n" +
+		"# must be a table. The alternative would be quite weird. Namely, it wouldn't\n" +
+		"# comply with the TOML spec: \"Each double-bracketed sub-table will belong to \n" +
+		"# the most *recently* defined table element *above* it.\"\n" +
+		"#\n" +
+		"# This is in contrast to the *valid* test, table-array-implicit where\n" +
+		"# `[[albums.songs]]` works by itself, so long as `[[albums]]` isn't declared\n" +
+		"# later. (Although, `[albums]` could be.)\n" +
+		"[[albums.songs]]\n" +
+		"name = \"Glory Days\"\n" +
+		"\n" +
+		"[[albums]]\n" +
+		"name = \"Born in the USA\"\n"
+	testgenInvalid(t, input)
+}
+
+func TestInvalidTableArrayMalformedBracket(t *testing.T) {
+	input := `[[albums]
+name = "Born to Run"`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidTableArrayMalformedEmpty(t *testing.T) {
+	input := `[[]]
+name = "Born to Run"`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidTableEmpty(t *testing.T) {
+	input := `[]`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidTableNestedBracketsClose(t *testing.T) {
+	input := `[a]b]
+zyx = 42`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidTableNestedBracketsOpen(t *testing.T) {
+	input := `[a[b]
+zyx = 42`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidTableWhitespace(t *testing.T) {
+	input := `[invalid key]`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidTableWithPound(t *testing.T) {
+	input := `[key#group]
+answer = 42`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidTextAfterArrayEntries(t *testing.T) {
+	input := `array = [
+  "Is there life after an array separator?", No
+  "Entry"
+]`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidTextAfterInteger(t *testing.T) {
+	input := `answer = 42 the ultimate answer?`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidTextAfterString(t *testing.T) {
+	input := `string = "Is there life after strings?" No.`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidTextAfterTable(t *testing.T) {
+	input := `[error] this shouldn't be here`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidTextBeforeArraySeparator(t *testing.T) {
+	input := `array = [
+  "Is there life before an array separator?" No,
+  "Entry"
+]`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidTextInArray(t *testing.T) {
+	input := `array = [
+  "Entry 1",
+  I don't belong,
+  "Entry 2",
+]`
+	testgenInvalid(t, input)
+}
+
+func TestValidArrayEmpty(t *testing.T) {
+	input := `thevoid = [[[[[]]]]]`
+	jsonRef := `{
+    "thevoid": { "type": "array", "value": [
+        {"type": "array", "value": [
+            {"type": "array", "value": [
+                {"type": "array", "value": [
+                    {"type": "array", "value": []}
+                ]}
+            ]}
+        ]}
+    ]}
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidArrayNospaces(t *testing.T) {
+	input := `ints = [1,2,3]`
+	jsonRef := `{
+    "ints": {
+        "type": "array",
+        "value": [
+            {"type": "integer", "value": "1"},
+            {"type": "integer", "value": "2"},
+            {"type": "integer", "value": "3"}
+        ]
+    }
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidArraysHetergeneous(t *testing.T) {
+	input := `mixed = [[1, 2], ["a", "b"], [1.1, 2.1]]`
+	jsonRef := `{
+    "mixed": {
+        "type": "array",
+        "value": [
+            {"type": "array", "value": [
+                {"type": "integer", "value": "1"},
+                {"type": "integer", "value": "2"}
+            ]},
+            {"type": "array", "value": [
+                {"type": "string", "value": "a"},
+                {"type": "string", "value": "b"}
+            ]},
+            {"type": "array", "value": [
+                {"type": "float", "value": "1.1"},
+                {"type": "float", "value": "2.1"}
+            ]}
+        ]
+    }
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidArraysNested(t *testing.T) {
+	input := `nest = [["a"], ["b"]]`
+	jsonRef := `{
+    "nest": {
+        "type": "array",
+        "value": [
+            {"type": "array", "value": [
+                {"type": "string", "value": "a"}
+            ]},
+            {"type": "array", "value": [
+                {"type": "string", "value": "b"}
+            ]}
+        ]
+    }
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidArrays(t *testing.T) {
+	input := `ints = [1, 2, 3]
+floats = [1.1, 2.1, 3.1]
+strings = ["a", "b", "c"]
+dates = [
+  1987-07-05T17:45:00Z,
+  1979-05-27T07:32:00Z,
+  2006-06-01T11:00:00Z,
+]`
+	jsonRef := `{
+    "ints": {
+        "type": "array",
+        "value": [
+            {"type": "integer", "value": "1"},
+            {"type": "integer", "value": "2"},
+            {"type": "integer", "value": "3"}
+        ]
+    },
+    "floats": {
+        "type": "array",
+        "value": [
+            {"type": "float", "value": "1.1"},
+            {"type": "float", "value": "2.1"},
+            {"type": "float", "value": "3.1"}
+        ]
+    },
+    "strings": {
+        "type": "array",
+        "value": [
+            {"type": "string", "value": "a"},
+            {"type": "string", "value": "b"},
+            {"type": "string", "value": "c"}
+        ]
+    },
+    "dates": {
+        "type": "array",
+        "value": [
+            {"type": "datetime", "value": "1987-07-05T17:45:00Z"},
+            {"type": "datetime", "value": "1979-05-27T07:32:00Z"},
+            {"type": "datetime", "value": "2006-06-01T11:00:00Z"}
+        ]
+    }
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidBool(t *testing.T) {
+	input := `t = true
+f = false`
+	jsonRef := `{
+    "f": {"type": "bool", "value": "false"},
+    "t": {"type": "bool", "value": "true"}
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidCommentsEverywhere(t *testing.T) {
+	input := `# Top comment.
+  # Top comment.
+# Top comment.
+
+# [no-extraneous-groups-please]
+
+[group] # Comment
+answer = 42 # Comment
+# no-extraneous-keys-please = 999
+# Inbetween comment.
+more = [ # Comment
+  # What about multiple # comments?
+  # Can you handle it?
+  #
+          # Evil.
+# Evil.
+  42, 42, # Comments within arrays are fun.
+  # What about multiple # comments?
+  # Can you handle it?
+  #
+          # Evil.
+# Evil.
+# ] Did I fool you?
+] # Hopefully not.`
+	jsonRef := `{
+    "group": {
+        "answer": {"type": "integer", "value": "42"},
+        "more": {
+            "type": "array",
+            "value": [
+                {"type": "integer", "value": "42"},
+                {"type": "integer", "value": "42"}
+            ]
+        }
+    }
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidDatetime(t *testing.T) {
+	input := `bestdayever = 1987-07-05T17:45:00Z`
+	jsonRef := `{
+    "bestdayever": {"type": "datetime", "value": "1987-07-05T17:45:00Z"}
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidEmpty(t *testing.T) {
+	input := ``
+	jsonRef := `{}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidExample(t *testing.T) {
+	input := `best-day-ever = 1987-07-05T17:45:00Z
+
+[numtheory]
+boring = false
+perfection = [6, 28, 496]`
+	jsonRef := `{
+  "best-day-ever": {"type": "datetime", "value": "1987-07-05T17:45:00Z"},
+  "numtheory": {
+    "boring": {"type": "bool", "value": "false"},
+    "perfection": {
+      "type": "array",
+      "value": [
+        {"type": "integer", "value": "6"},
+        {"type": "integer", "value": "28"},
+        {"type": "integer", "value": "496"}
+      ]
+    }
+  }
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidFloat(t *testing.T) {
+	input := `pi = 3.14
+negpi = -3.14`
+	jsonRef := `{
+    "pi": {"type": "float", "value": "3.14"},
+    "negpi": {"type": "float", "value": "-3.14"}
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidImplicitAndExplicitAfter(t *testing.T) {
+	input := `[a.b.c]
+answer = 42
+
+[a]
+better = 43`
+	jsonRef := `{
+    "a": {
+        "better": {"type": "integer", "value": "43"},
+        "b": {
+            "c": {
+                "answer": {"type": "integer", "value": "42"}
+            }
+        }
+    }
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidImplicitAndExplicitBefore(t *testing.T) {
+	input := `[a]
+better = 43
+
+[a.b.c]
+answer = 42`
+	jsonRef := `{
+    "a": {
+        "better": {"type": "integer", "value": "43"},
+        "b": {
+            "c": {
+                "answer": {"type": "integer", "value": "42"}
+            }
+        }
+    }
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidImplicitGroups(t *testing.T) {
+	input := `[a.b.c]
+answer = 42`
+	jsonRef := `{
+    "a": {
+        "b": {
+            "c": {
+                "answer": {"type": "integer", "value": "42"}
+            }
+        }
+    }
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidInteger(t *testing.T) {
+	input := `answer = 42
+neganswer = -42`
+	jsonRef := `{
+    "answer": {"type": "integer", "value": "42"},
+    "neganswer": {"type": "integer", "value": "-42"}
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidKeyEqualsNospace(t *testing.T) {
+	input := `answer=42`
+	jsonRef := `{
+    "answer": {"type": "integer", "value": "42"}
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidKeySpace(t *testing.T) {
+	input := `"a b" = 1`
+	jsonRef := `{
+    "a b": {"type": "integer", "value": "1"}
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidKeySpecialChars(t *testing.T) {
+	input := "\"~!@$^&*()_+-`1234567890[]|/?><.,;:'\" = 1\n"
+	jsonRef := "{\n" +
+		"    \"~!@$^&*()_+-`1234567890[]|/?><.,;:'\": {\n" +
+		"        \"type\": \"integer\", \"value\": \"1\"\n" +
+		"    }\n" +
+		"}\n"
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidLongFloat(t *testing.T) {
+	input := `longpi = 3.141592653589793
+neglongpi = -3.141592653589793`
+	jsonRef := `{
+    "longpi": {"type": "float", "value": "3.141592653589793"},
+    "neglongpi": {"type": "float", "value": "-3.141592653589793"}
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidLongInteger(t *testing.T) {
+	input := `answer = 9223372036854775807
+neganswer = -9223372036854775808`
+	jsonRef := `{
+    "answer": {"type": "integer", "value": "9223372036854775807"},
+    "neganswer": {"type": "integer", "value": "-9223372036854775808"}
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidMultilineString(t *testing.T) {
+	input := `multiline_empty_one = """"""
+multiline_empty_two = """
+"""
+multiline_empty_three = """\
+    """
+multiline_empty_four = """\
+   \
+   \
+   """
+
+equivalent_one = "The quick brown fox jumps over the lazy dog."
+equivalent_two = """
+The quick brown \
+
+
+  fox jumps over \
+    the lazy dog."""
+
+equivalent_three = """\
+       The quick brown \
+       fox jumps over \
+       the lazy dog.\
+       """`
+	jsonRef := `{
+    "multiline_empty_one": {
+        "type": "string",
+        "value": ""
+    },
+    "multiline_empty_two": {
+        "type": "string",
+        "value": ""
+    },
+    "multiline_empty_three": {
+        "type": "string",
+        "value": ""
+    },
+    "multiline_empty_four": {
+        "type": "string",
+        "value": ""
+    },
+    "equivalent_one": {
+        "type": "string",
+        "value": "The quick brown fox jumps over the lazy dog."
+    },
+    "equivalent_two": {
+        "type": "string",
+        "value": "The quick brown fox jumps over the lazy dog."
+    },
+    "equivalent_three": {
+        "type": "string",
+        "value": "The quick brown fox jumps over the lazy dog."
+    }
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidRawMultilineString(t *testing.T) {
+	input := `oneline = '''This string has a ' quote character.'''
+firstnl = '''
+This string has a ' quote character.'''
+multiline = '''
+This string
+has ' a quote character
+and more than
+one newline
+in it.'''`
+	jsonRef := `{
+    "oneline": {
+        "type": "string",
+        "value": "This string has a ' quote character."
+    },
+    "firstnl": {
+        "type": "string",
+        "value": "This string has a ' quote character."
+    },
+    "multiline": {
+        "type": "string",
+        "value": "This string\nhas ' a quote character\nand more than\none newline\nin it."
+    }
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidRawString(t *testing.T) {
+	input := `backspace = 'This string has a \b backspace character.'
+tab = 'This string has a \t tab character.'
+newline = 'This string has a \n new line character.'
+formfeed = 'This string has a \f form feed character.'
+carriage = 'This string has a \r carriage return character.'
+slash = 'This string has a \/ slash character.'
+backslash = 'This string has a \\ backslash character.'`
+	jsonRef := `{
+    "backspace": {
+        "type": "string",
+        "value": "This string has a \\b backspace character."
+    },
+    "tab": {
+        "type": "string",
+        "value": "This string has a \\t tab character."
+    },
+    "newline": {
+        "type": "string",
+        "value": "This string has a \\n new line character."
+    },
+    "formfeed": {
+        "type": "string",
+        "value": "This string has a \\f form feed character."
+    },
+    "carriage": {
+        "type": "string",
+        "value": "This string has a \\r carriage return character."
+    },
+    "slash": {
+        "type": "string",
+        "value": "This string has a \\/ slash character."
+    },
+    "backslash": {
+        "type": "string",
+        "value": "This string has a \\\\ backslash character."
+    }
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidStringEmpty(t *testing.T) {
+	input := `answer = ""`
+	jsonRef := `{
+    "answer": {
+        "type": "string",
+        "value": ""
+    }
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidStringEscapes(t *testing.T) {
+	input := `backspace = "This string has a \b backspace character."
+tab = "This string has a \t tab character."
+newline = "This string has a \n new line character."
+formfeed = "This string has a \f form feed character."
+carriage = "This string has a \r carriage return character."
+quote = "This string has a \" quote character."
+backslash = "This string has a \\ backslash character."
+notunicode1 = "This string does not have a unicode \\u escape."
+notunicode2 = "This string does not have a unicode \u005Cu escape."
+notunicode3 = "This string does not have a unicode \\u0075 escape."
+notunicode4 = "This string does not have a unicode \\\u0075 escape."`
+	jsonRef := `{
+    "backspace": {
+        "type": "string",
+        "value": "This string has a \u0008 backspace character."
+    },
+    "tab": {
+        "type": "string",
+        "value": "This string has a \u0009 tab character."
+    },
+    "newline": {
+        "type": "string",
+        "value": "This string has a \u000A new line character."
+    },
+    "formfeed": {
+        "type": "string",
+        "value": "This string has a \u000C form feed character."
+    },
+    "carriage": {
+        "type": "string",
+        "value": "This string has a \u000D carriage return character."
+    },
+    "quote": {
+        "type": "string",
+        "value": "This string has a \u0022 quote character."
+    },
+    "backslash": {
+        "type": "string",
+        "value": "This string has a \u005C backslash character."
+    },
+    "notunicode1": {
+        "type": "string",
+        "value": "This string does not have a unicode \\u escape."
+    },
+    "notunicode2": {
+        "type": "string",
+        "value": "This string does not have a unicode \u005Cu escape."
+    },
+    "notunicode3": {
+        "type": "string",
+        "value": "This string does not have a unicode \\u0075 escape."
+    },
+    "notunicode4": {
+        "type": "string",
+        "value": "This string does not have a unicode \\\u0075 escape."
+    }
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidStringSimple(t *testing.T) {
+	input := `answer = "You are not drinking enough whisky."`
+	jsonRef := `{
+    "answer": {
+        "type": "string",
+        "value": "You are not drinking enough whisky."
+    }
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidStringWithPound(t *testing.T) {
+	input := `pound = "We see no # comments here."
+poundcomment = "But there are # some comments here." # Did I # mess you up?`
+	jsonRef := `{
+    "pound": {"type": "string", "value": "We see no # comments here."},
+    "poundcomment": {
+        "type": "string",
+        "value": "But there are # some comments here."
+    }
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidTableArrayImplicit(t *testing.T) {
+	input := `[[albums.songs]]
+name = "Glory Days"`
+	jsonRef := `{
+    "albums": {
+       "songs": [
+           {"name": {"type": "string", "value": "Glory Days"}}
+       ]
+    }
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidTableArrayMany(t *testing.T) {
+	input := `[[people]]
+first_name = "Bruce"
+last_name = "Springsteen"
+
+[[people]]
+first_name = "Eric"
+last_name = "Clapton"
+
+[[people]]
+first_name = "Bob"
+last_name = "Seger"`
+	jsonRef := `{
+    "people": [
+        {
+            "first_name": {"type": "string", "value": "Bruce"},
+            "last_name": {"type": "string", "value": "Springsteen"}
+        },
+        {
+            "first_name": {"type": "string", "value": "Eric"},
+            "last_name": {"type": "string", "value": "Clapton"}
+        },
+        {
+            "first_name": {"type": "string", "value": "Bob"},
+            "last_name": {"type": "string", "value": "Seger"}
+        }
+    ]
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidTableArrayNest(t *testing.T) {
+	input := `[[albums]]
+name = "Born to Run"
+
+  [[albums.songs]]
+  name = "Jungleland"
+
+  [[albums.songs]]
+  name = "Meeting Across the River"
+
+[[albums]]
+name = "Born in the USA"
+  
+  [[albums.songs]]
+  name = "Glory Days"
+
+  [[albums.songs]]
+  name = "Dancing in the Dark"`
+	jsonRef := `{
+    "albums": [
+        {
+            "name": {"type": "string", "value": "Born to Run"},
+            "songs": [
+                {"name": {"type": "string", "value": "Jungleland"}},
+                {"name": {"type": "string", "value": "Meeting Across the River"}}
+            ]
+        },
+        {
+            "name": {"type": "string", "value": "Born in the USA"},
+            "songs": [
+                {"name": {"type": "string", "value": "Glory Days"}},
+                {"name": {"type": "string", "value": "Dancing in the Dark"}}
+            ]
+        }
+    ]
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidTableArrayOne(t *testing.T) {
+	input := `[[people]]
+first_name = "Bruce"
+last_name = "Springsteen"`
+	jsonRef := `{
+    "people": [
+        {
+            "first_name": {"type": "string", "value": "Bruce"},
+            "last_name": {"type": "string", "value": "Springsteen"}
+        }
+    ]
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidTableEmpty(t *testing.T) {
+	input := `[a]`
+	jsonRef := `{
+    "a": {}
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidTableSubEmpty(t *testing.T) {
+	input := `[a]
+[a.b]`
+	jsonRef := `{
+    "a": { "b": {} }
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidTableWhitespace(t *testing.T) {
+	input := `["valid key"]`
+	jsonRef := `{
+    "valid key": {}
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidTableWithPound(t *testing.T) {
+	input := `["key#group"]
+answer = 42`
+	jsonRef := `{
+    "key#group": {
+        "answer": {"type": "integer", "value": "42"}
+    }
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidUnicodeEscape(t *testing.T) {
+	input := `answer4 = "\u03B4"
+answer8 = "\U000003B4"`
+	jsonRef := `{
+    "answer4": {"type": "string", "value": "\u03B4"},
+    "answer8": {"type": "string", "value": "\u03B4"}
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidUnicodeLiteral(t *testing.T) {
+	input := `answer = "δ"`
+	jsonRef := `{
+    "answer": {"type": "string", "value": "δ"}
+}`
+	testgenValid(t, input, jsonRef)
+}

tomltree_create.go

@@ -104,7 +104,7 @@ func sliceToTree(object interface{}) (interface{}, error) {
 		}
 		arrayValue = reflect.Append(arrayValue, reflect.ValueOf(simpleValue))
 	}
-	return &tomlValue{arrayValue.Interface(), Position{}}, nil
+	return &tomlValue{value: arrayValue.Interface(), position: Position{}}, nil
 }
 
 func toTree(object interface{}) (interface{}, error) {
@@ -127,7 +127,7 @@ func toTree(object interface{}) (interface{}, error) {
 			}
 			values[key.String()] = newValue
 		}
-		return &Tree{values, Position{}}, nil
+		return &Tree{values: values, position: Position{}}, nil
 	}
 
 	if value.Kind() == reflect.Array || value.Kind() == reflect.Slice {
@@ -138,5 +138,5 @@ func toTree(object interface{}) (interface{}, error) {
 	if err != nil {
 		return nil, err
 	}
-	return &tomlValue{simpleValue, Position{}}, nil
+	return &tomlValue{value: simpleValue, position: Position{}}, nil
 }

tomltree_create_test.go

@@ -60,7 +60,7 @@ func TestTreeCreateToTree(t *testing.T) {
 		},
 		"array":                 []string{"a", "b", "c"},
 		"array_uint":            []uint{uint(1), uint(2)},
-		"array_table":           []map[string]interface{}{map[string]interface{}{"sub_map": 52}},
+		"array_table":           []map[string]interface{}{{"sub_map": 52}},
 		"array_times":           []time.Time{time.Now(), time.Now()},
 		"map_times":             map[string]time.Time{"now": time.Now()},
 		"custom_string_map_key": map[customString]interface{}{customString("custom"): "custom"},
@@ -97,7 +97,7 @@ func TestTreeCreateToTreeInvalidArrayMemberType(t *testing.T) {
 }
 
 func TestTreeCreateToTreeInvalidTableGroupType(t *testing.T) {
-	_, err := TreeFromMap(map[string]interface{}{"foo": []map[string]interface{}{map[string]interface{}{"hello": t}}})
+	_, err := TreeFromMap(map[string]interface{}{"foo": []map[string]interface{}{{"hello": t}}})
 	expected := "cannot convert type *testing.T to Tree"
 	if err.Error() != expected {
 		t.Fatalf("expected error %s, got %s", expected, err.Error())

tomltree_write.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"io"
 	"math"
+	"math/big"
 	"reflect"
 	"sort"
 	"strconv"
@@ -12,7 +13,53 @@ import (
 	"time"
 )
 
-// encodes a string to a TOML-compliant string value
+type valueComplexity int
+
+const (
+	valueSimple valueComplexity = iota + 1
+	valueComplex
+)
+
+type sortNode struct {
+	key        string
+	complexity valueComplexity
+}
+
+// Encodes a string to a TOML-compliant multi-line string value
+// This function is a clone of the existing encodeTomlString function, except that whitespace characters
+// are preserved. Quotation marks and backslashes are also not escaped.
+func encodeMultilineTomlString(value string) string {
+	var b bytes.Buffer
+
+	for _, rr := range value {
+		switch rr {
+		case '\b':
+			b.WriteString(`\b`)
+		case '\t':
+			b.WriteString("\t")
+		case '\n':
+			b.WriteString("\n")
+		case '\f':
+			b.WriteString(`\f`)
+		case '\r':
+			b.WriteString("\r")
+		case '"':
+			b.WriteString(`"`)
+		case '\\':
+			b.WriteString(`\`)
+		default:
+			intRr := uint16(rr)
+			if intRr < 0x001F {
+				b.WriteString(fmt.Sprintf("\\u%0.4X", intRr))
+			} else {
+				b.WriteRune(rr)
+			}
+		}
+	}
+	return b.String()
+}
+
+// Encodes a string to a TOML-compliant string value
 func encodeTomlString(value string) string {
 	var b bytes.Buffer
 
@@ -44,24 +91,44 @@ func encodeTomlString(value string) string {
 	return b.String()
 }
 
-func tomlValueStringRepresentation(v interface{}) (string, error) {
+func tomlValueStringRepresentation(v interface{}, indent string, arraysOneElementPerLine bool) (string, error) {
+	// this interface check is added to dereference the change made in the writeTo function.
+	// That change was made to allow this function to see formatting options.
+	tv, ok := v.(*tomlValue)
+	if ok {
+		v = tv.value
+	} else {
+		tv = &tomlValue{}
+	}
+
 	switch value := v.(type) {
 	case uint64:
 		return strconv.FormatUint(value, 10), nil
 	case int64:
 		return strconv.FormatInt(value, 10), nil
 	case float64:
-		// Ensure a round float does contain a decimal point. Otherwise feeding
+		// Default bit length is full 64
-		// the output back to the parser would convert to an integer.
+		bits := 64
-		if math.Trunc(value) == value {
+		// Float panics if nan is used
-			return strconv.FormatFloat(value, 'f', 1, 32), nil
+		if !math.IsNaN(value) {
+			// if 32 bit accuracy is enough to exactly show, use 32
+			_, acc := big.NewFloat(value).Float32()
+			if acc == big.Exact {
+				bits = 32
+			}
 		}
-		return strconv.FormatFloat(value, 'f', -1, 32), nil
+		if math.Trunc(value) == value {
+			return strings.ToLower(strconv.FormatFloat(value, 'f', 1, bits)), nil
+		}
+		return strings.ToLower(strconv.FormatFloat(value, 'f', -1, bits)), nil
 	case string:
+		if tv.multiline {
+			return "\"\"\"\n" + encodeMultilineTomlString(value) + "\"\"\"", nil
+		}
 		return "\"" + encodeTomlString(value) + "\"", nil
 	case []byte:
 		b, _ := v.([]byte)
-		return tomlValueStringRepresentation(string(b))
+		return tomlValueStringRepresentation(string(b), indent, arraysOneElementPerLine)
 	case bool:
 		if value {
 			return "true", nil
@@ -76,87 +143,231 @@ func tomlValueStringRepresentation(v interface{}) (string, error) {
 	rv := reflect.ValueOf(v)
 
 	if rv.Kind() == reflect.Slice {
-		values := []string{}
+		var values []string
 		for i := 0; i < rv.Len(); i++ {
 			item := rv.Index(i).Interface()
-			itemRepr, err := tomlValueStringRepresentation(item)
+			itemRepr, err := tomlValueStringRepresentation(item, indent, arraysOneElementPerLine)
 			if err != nil {
 				return "", err
 			}
 			values = append(values, itemRepr)
 		}
+		if arraysOneElementPerLine && len(values) > 1 {
+			stringBuffer := bytes.Buffer{}
+			valueIndent := indent + `  ` // TODO: move that to a shared encoder state
+
+			stringBuffer.WriteString("[\n")
+
+			for _, value := range values {
+				stringBuffer.WriteString(valueIndent)
+				stringBuffer.WriteString(value)
+				stringBuffer.WriteString(`,`)
+				stringBuffer.WriteString("\n")
+			}
+
+			stringBuffer.WriteString(indent + "]")
+
+			return stringBuffer.String(), nil
+		}
 		return "[" + strings.Join(values, ",") + "]", nil
 	}
 	return "", fmt.Errorf("unsupported value type %T: %v", v, v)
 }
 
-func (t *Tree) writeTo(w io.Writer, indent, keyspace string, bytesCount int64) (int64, error) {
+func getTreeArrayLine(trees []*Tree) (line int) {
-	simpleValuesKeys := make([]string, 0)
+	// get lowest line number that is not 0
-	complexValuesKeys := make([]string, 0)
+	for _, tv := range trees {
+		if tv.position.Line < line || line == 0 {
+			line = tv.position.Line
+		}
+	}
+	return
+}
+
+func sortByLines(t *Tree) (vals []sortNode) {
+	var (
+		line  int
+		lines []int
+		tv    *Tree
+		tom   *tomlValue
+		node  sortNode
+	)
+	vals = make([]sortNode, 0)
+	m := make(map[int]sortNode)
+
+	for k := range t.values {
+		v := t.values[k]
+		switch v.(type) {
+		case *Tree:
+			tv = v.(*Tree)
+			line = tv.position.Line
+			node = sortNode{key: k, complexity: valueComplex}
+		case []*Tree:
+			line = getTreeArrayLine(v.([]*Tree))
+			node = sortNode{key: k, complexity: valueComplex}
+		default:
+			tom = v.(*tomlValue)
+			line = tom.position.Line
+			node = sortNode{key: k, complexity: valueSimple}
+		}
+		lines = append(lines, line)
+		vals = append(vals, node)
+		m[line] = node
+	}
+	sort.Ints(lines)
+
+	for i, line := range lines {
+		vals[i] = m[line]
+	}
+
+	return vals
+}
+
+func sortAlphabetical(t *Tree) (vals []sortNode) {
+	var (
+		node     sortNode
+		simpVals []string
+		compVals []string
+	)
+	vals = make([]sortNode, 0)
+	m := make(map[string]sortNode)
 
 	for k := range t.values {
 		v := t.values[k]
 		switch v.(type) {
 		case *Tree, []*Tree:
-			complexValuesKeys = append(complexValuesKeys, k)
+			node = sortNode{key: k, complexity: valueComplex}
+			compVals = append(compVals, node.key)
 		default:
-			simpleValuesKeys = append(simpleValuesKeys, k)
+			node = sortNode{key: k, complexity: valueSimple}
+			simpVals = append(simpVals, node.key)
 		}
+		vals = append(vals, node)
+		m[node.key] = node
 	}
 
-	sort.Strings(simpleValuesKeys)
+	// Simples first to match previous implementation
-	sort.Strings(complexValuesKeys)
+	sort.Strings(simpVals)
-
+	i := 0
-	for _, k := range simpleValuesKeys {
+	for _, key := range simpVals {
-		v, ok := t.values[k].(*tomlValue)
+		vals[i] = m[key]
-		if !ok {
+		i++
-			return bytesCount, fmt.Errorf("invalid value type at %s: %T", k, t.values[k])
-		}
-
-		repr, err := tomlValueStringRepresentation(v.value)
-		if err != nil {
-			return bytesCount, err
-		}
-
-		writtenBytesCount, err := writeStrings(w, indent, k, " = ", repr, "\n")
-		bytesCount += int64(writtenBytesCount)
-		if err != nil {
-			return bytesCount, err
-		}
 	}
 
-	for _, k := range complexValuesKeys {
+	sort.Strings(compVals)
-		v := t.values[k]
+	for _, key := range compVals {
+		vals[i] = m[key]
+		i++
+	}
 
-		combinedKey := k
+	return vals
-		if keyspace != "" {
+}
-			combinedKey = keyspace + "." + combinedKey
-		}
 
-		switch node := v.(type) {
+func (t *Tree) writeTo(w io.Writer, indent, keyspace string, bytesCount int64, arraysOneElementPerLine bool) (int64, error) {
-		// node has to be of those two types given how keys are sorted above
+	return t.writeToOrdered(w, indent, keyspace, bytesCount, arraysOneElementPerLine, OrderAlphabetical)
-		case *Tree:
+}
-			writtenBytesCount, err := writeStrings(w, "\n", indent, "[", combinedKey, "]\n")
+
-			bytesCount += int64(writtenBytesCount)
+func (t *Tree) writeToOrdered(w io.Writer, indent, keyspace string, bytesCount int64, arraysOneElementPerLine bool, ord marshalOrder) (int64, error) {
-			if err != nil {
+	var orderedVals []sortNode
-				return bytesCount, err
+
+	switch ord {
+	case OrderPreserve:
+		orderedVals = sortByLines(t)
+	default:
+		orderedVals = sortAlphabetical(t)
+	}
+
+	for _, node := range orderedVals {
+		switch node.complexity {
+		case valueComplex:
+			k := node.key
+			v := t.values[k]
+
+			combinedKey := k
+			if keyspace != "" {
+				combinedKey = keyspace + "." + combinedKey
 			}
-			bytesCount, err = node.writeTo(w, indent+"  ", combinedKey, bytesCount)
+			var commented string
-			if err != nil {
+			if t.commented {
-				return bytesCount, err
+				commented = "# "
 			}
-		case []*Tree:
+
-			for _, subTree := range node {
+			switch node := v.(type) {
-				writtenBytesCount, err := writeStrings(w, "\n", indent, "[[", combinedKey, "]]\n")
+			// node has to be of those two types given how keys are sorted above
+			case *Tree:
+				tv, ok := t.values[k].(*Tree)
+				if !ok {
+					return bytesCount, fmt.Errorf("invalid value type at %s: %T", k, t.values[k])
+				}
+				if tv.comment != "" {
+					comment := strings.Replace(tv.comment, "\n", "\n"+indent+"#", -1)
+					start := "# "
+					if strings.HasPrefix(comment, "#") {
+						start = ""
+					}
+					writtenBytesCountComment, errc := writeStrings(w, "\n", indent, start, comment)
+					bytesCount += int64(writtenBytesCountComment)
+					if errc != nil {
+						return bytesCount, errc
+					}
+				}
+				writtenBytesCount, err := writeStrings(w, "\n", indent, commented, "[", combinedKey, "]\n")
 				bytesCount += int64(writtenBytesCount)
 				if err != nil {
 					return bytesCount, err
 				}
-
+				bytesCount, err = node.writeToOrdered(w, indent+"  ", combinedKey, bytesCount, arraysOneElementPerLine, ord)
-				bytesCount, err = subTree.writeTo(w, indent+"  ", combinedKey, bytesCount)
 				if err != nil {
 					return bytesCount, err
 				}
+			case []*Tree:
+				for _, subTree := range node {
+					writtenBytesCount, err := writeStrings(w, "\n", indent, commented, "[[", combinedKey, "]]\n")
+					bytesCount += int64(writtenBytesCount)
+					if err != nil {
+						return bytesCount, err
+					}
+
+					bytesCount, err = subTree.writeToOrdered(w, indent+"  ", combinedKey, bytesCount, arraysOneElementPerLine, ord)
+					if err != nil {
+						return bytesCount, err
+					}
+				}
+			}
+		default: // Simple
+			k := node.key
+			v, ok := t.values[k].(*tomlValue)
+			if !ok {
+				return bytesCount, fmt.Errorf("invalid value type at %s: %T", k, t.values[k])
+			}
+
+			repr, err := tomlValueStringRepresentation(v, indent, arraysOneElementPerLine)
+			if err != nil {
+				return bytesCount, err
+			}
+
+			if v.comment != "" {
+				comment := strings.Replace(v.comment, "\n", "\n"+indent+"#", -1)
+				start := "# "
+				if strings.HasPrefix(comment, "#") {
+					start = ""
+				}
+				writtenBytesCountComment, errc := writeStrings(w, "\n", indent, start, comment, "\n")
+				bytesCount += int64(writtenBytesCountComment)
+				if errc != nil {
+					return bytesCount, errc
+				}
+			}
+
+			var commented string
+			if v.commented {
+				commented = "# "
+			}
+			quotedKey := quoteKeyIfNeeded(k)
+			writtenBytesCount, err := writeStrings(w, indent, commented, quotedKey, " = ", repr, "\n")
+			bytesCount += int64(writtenBytesCount)
+			if err != nil {
+				return bytesCount, err
 			}
 		}
 	}
@@ -164,6 +375,32 @@ func (t *Tree) writeTo(w io.Writer, indent, keyspace string, bytesCount int64) (
 	return bytesCount, nil
 }
 
+// quote a key if it does not fit the bare key format (A-Za-z0-9_-)
+// quoted keys use the same rules as strings
+func quoteKeyIfNeeded(k string) string {
+	// when encoding a map with the 'quoteMapKeys' option enabled, the tree will contain
+	// keys that have already been quoted.
+	// not an ideal situation, but good enough of a stop gap.
+	if len(k) >= 2 && k[0] == '"' && k[len(k)-1] == '"' {
+		return k
+	}
+	isBare := true
+	for _, r := range k {
+		if !isValidBareChar(r) {
+			isBare = false
+			break
+		}
+	}
+	if isBare {
+		return k
+	}
+	return quoteKey(k)
+}
+
+func quoteKey(k string) string {
+	return "\"" + encodeTomlString(k) + "\""
+}
+
 func writeStrings(w io.Writer, s ...string) (int, error) {
 	var n int
 	for i := range s {
@@ -179,19 +416,18 @@ func writeStrings(w io.Writer, s ...string) (int, error) {
 // WriteTo encode the Tree as Toml and writes it to the writer w.
 // Returns the number of bytes written in case of success, or an error if anything happened.
 func (t *Tree) WriteTo(w io.Writer) (int64, error) {
-	return t.writeTo(w, "", "", 0)
+	return t.writeTo(w, "", "", 0, false)
 }
 
 // ToTomlString generates a human-readable representation of the current tree.
 // Output spans multiple lines, and is suitable for ingest by a TOML parser.
 // If the conversion cannot be performed, ToString returns a non-nil error.
 func (t *Tree) ToTomlString() (string, error) {
-	var buf bytes.Buffer
+	b, err := t.Marshal()
-	_, err := t.WriteTo(&buf)
 	if err != nil {
 		return "", err
 	}
-	return buf.String(), nil
+	return string(b), nil
 }
 
 // String generates a human-readable representation of the current tree.

tomltree_write_test.go

@@ -30,7 +30,7 @@ func (f *failingWriter) Write(p []byte) (n int, err error) {
 
 	f.buffer.Write(p[:toWrite])
 	f.written = f.failAt
-	return toWrite, fmt.Errorf("failingWriter failed after writting %d bytes", f.written)
+	return toWrite, fmt.Errorf("failingWriter failed after writing %d bytes", f.written)
 }
 
 func assertErrorString(t *testing.T, expected string, err error) {
@@ -161,13 +161,13 @@ func TestTreeWriteToInvalidTreeSimpleValue(t *testing.T) {
 }
 
 func TestTreeWriteToInvalidTreeTomlValue(t *testing.T) {
-	tree := Tree{values: map[string]interface{}{"foo": &tomlValue{int8(1), Position{}}}}
+	tree := Tree{values: map[string]interface{}{"foo": &tomlValue{value: int8(1), comment: "", position: Position{}}}}
 	_, err := tree.ToTomlString()
 	assertErrorString(t, "unsupported value type int8: 1", err)
 }
 
 func TestTreeWriteToInvalidTreeTomlValueArray(t *testing.T) {
-	tree := Tree{values: map[string]interface{}{"foo": &tomlValue{[]interface{}{int8(1)}, Position{}}}}
+	tree := Tree{values: map[string]interface{}{"foo": &tomlValue{value: int8(1), comment: "", position: Position{}}}}
 	_, err := tree.ToTomlString()
 	assertErrorString(t, "unsupported value type int8: 1", err)
 }
@@ -176,7 +176,7 @@ func TestTreeWriteToFailingWriterInSimpleValue(t *testing.T) {
 	toml, _ := Load(`a = 2`)
 	writer := failingWriter{failAt: 0, written: 0}
 	_, err := toml.WriteTo(&writer)
-	assertErrorString(t, "failingWriter failed after writting 0 bytes", err)
+	assertErrorString(t, "failingWriter failed after writing 0 bytes", err)
 }
 
 func TestTreeWriteToFailingWriterInTable(t *testing.T) {
@@ -185,11 +185,11 @@ func TestTreeWriteToFailingWriterInTable(t *testing.T) {
 a = 2`)
 	writer := failingWriter{failAt: 2, written: 0}
 	_, err := toml.WriteTo(&writer)
-	assertErrorString(t, "failingWriter failed after writting 2 bytes", err)
+	assertErrorString(t, "failingWriter failed after writing 2 bytes", err)
 
 	writer = failingWriter{failAt: 13, written: 0}
 	_, err = toml.WriteTo(&writer)
-	assertErrorString(t, "failingWriter failed after writting 13 bytes", err)
+	assertErrorString(t, "failingWriter failed after writing 13 bytes", err)
 }
 
 func TestTreeWriteToFailingWriterInArray(t *testing.T) {
@@ -198,11 +198,11 @@ func TestTreeWriteToFailingWriterInArray(t *testing.T) {
 a = 2`)
 	writer := failingWriter{failAt: 2, written: 0}
 	_, err := toml.WriteTo(&writer)
-	assertErrorString(t, "failingWriter failed after writting 2 bytes", err)
+	assertErrorString(t, "failingWriter failed after writing 2 bytes", err)
 
 	writer = failingWriter{failAt: 15, written: 0}
 	_, err = toml.WriteTo(&writer)
-	assertErrorString(t, "failingWriter failed after writting 15 bytes", err)
+	assertErrorString(t, "failingWriter failed after writing 15 bytes", err)
 }
 
 func TestTreeWriteToMapExampleFile(t *testing.T) {
@@ -309,6 +309,48 @@ func TestTreeWriteToFloat(t *testing.T) {
 	}
 }
 
+func TestTreeWriteToSpecialFloat(t *testing.T) {
+	expected := `a = +inf
+b = -inf
+c = nan`
+
+	tree, err := Load(expected)
+	if err != nil {
+		t.Fatal(err)
+	}
+	str, err := tree.ToTomlString()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if strings.TrimSpace(str) != strings.TrimSpace(expected) {
+		t.Fatalf("Expected:\n%s\nGot:\n%s", expected, str)
+	}
+}
+
+func TestIssue290(t *testing.T) {
+	tomlString :=
+		`[table]
+"127.0.0.1" = "value"
+"127.0.0.1:8028" = "value"
+"character encoding" = "value"
+"ʎǝʞ" = "value"`
+
+	t1, err := Load(tomlString)
+	if err != nil {
+		t.Fatal("load err:", err)
+	}
+
+	s, err := t1.ToTomlString()
+	if err != nil {
+		t.Fatal("ToTomlString err:", err)
+	}
+
+	_, err = Load(s)
+	if err != nil {
+		t.Fatal("reload err:", err)
+	}
+}
+
 func BenchmarkTreeToTomlString(b *testing.B) {
 	toml, err := Load(sampleHard)
 	if err != nil {