TOML 0.5.0 (#320)

go-toml now officially supports all TOML 0.5.0 features. If anything
does not work according to the spec, please file a bug!

README.md

@@ -3,7 +3,7 @@
 Go library for the [TOML](https://github.com/mojombo/toml) format.
 
 This library supports TOML version
-[v0.4.0](https://github.com/toml-lang/toml/blob/master/versions/en/toml-v0.4.0.md)
+[v0.5.0](https://github.com/toml-lang/toml/blob/master/versions/en/toml-v0.5.0.md)
 
 [![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)

doc.go

@@ -1,7 +1,7 @@
 // Package toml is a TOML parser and manipulation library.
 //
 // This version supports the specification as described in
-// https://github.com/toml-lang/toml/blob/master/versions/en/toml-v0.4.0.md
+// https://github.com/toml-lang/toml/blob/master/versions/en/toml-v0.5.0.md
 //
 // Marshaling
 //

lexer.go

@@ -223,9 +223,12 @@ func (l *tomlLexer) lexRvalue() tomlLexStateFn {
 		}
 
 		possibleDate := l.peekString(35)
-		dateMatch := dateRegexp.FindString(possibleDate)
+		dateSubmatches := dateRegexp.FindStringSubmatch(possibleDate)
-		if dateMatch != "" {
+		if dateSubmatches != nil && dateSubmatches[0] != "" {
-			l.fastForward(len(dateMatch))
+			l.fastForward(len(dateSubmatches[0]))
+			if dateSubmatches[2] == "" { // no timezone information => local date
+				return l.lexLocalDate
+			}
 			return l.lexDate
 		}
 
@@ -247,13 +250,13 @@ func (l *tomlLexer) lexRvalue() tomlLexStateFn {
 func (l *tomlLexer) lexLeftCurlyBrace() tomlLexStateFn {
 	l.next()
 	l.emit(tokenLeftCurlyBrace)
-	return l.lexRvalue
+	return l.lexVoid
 }
 
 func (l *tomlLexer) lexRightCurlyBrace() tomlLexStateFn {
 	l.next()
 	l.emit(tokenRightCurlyBrace)
-	return l.lexRvalue
+	return l.lexVoid
 }
 
 func (l *tomlLexer) lexDate() tomlLexStateFn {
@@ -261,6 +264,11 @@ func (l *tomlLexer) lexDate() tomlLexStateFn {
 	return l.lexRvalue
 }
 
+func (l *tomlLexer) lexLocalDate() tomlLexStateFn {
+	l.emit(tokenLocalDate)
+	return l.lexRvalue
+}
+
 func (l *tomlLexer) lexTrue() tomlLexStateFn {
 	l.fastForward(4)
 	l.emit(tokenTrue)
@@ -733,7 +741,27 @@ 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})`)
+	// Regexp for all date/time formats supported by TOML.
+	// Group 1: nano precision
+	// Group 2: timezone
+	//
+	// /!\ also matches the empty string
+	//
+	// Example matches:
+	//1979-05-27T07:32:00Z
+	//1979-05-27T00:32:00-07:00
+	//1979-05-27T00:32:00.999999-07:00
+	//1979-05-27 07:32:00Z
+	//1979-05-27 00:32:00-07:00
+	//1979-05-27 00:32:00.999999-07:00
+	//1979-05-27T07:32:00
+	//1979-05-27T00:32:00.999999
+	//1979-05-27 07:32:00
+	//1979-05-27 00:32:00.999999
+	//1979-05-27
+	//07:32:00
+	//00:32:00.999999
+	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

@@ -290,14 +290,26 @@ func TestKeyEqualArrayBoolsWithComments(t *testing.T) {
 }
 
 func TestDateRegexp(t *testing.T) {
-	if dateRegexp.FindString("1979-05-27T07:32:00Z") == "" {
+	cases := map[string]string{
-		t.Error("basic lexing")
+		"basic":               "1979-05-27T07:32:00Z",
+		"offset":              "1979-05-27T00:32:00-07:00",
+		"nano precision":      "1979-05-27T00:32:00.999999-07:00",
+		"basic-no-T":          "1979-05-27 07:32:00Z",
+		"offset-no-T":         "1979-05-27 00:32:00-07:00",
+		"nano precision-no-T": "1979-05-27 00:32:00.999999-07:00",
+		"no-tz":               "1979-05-27T07:32:00",
+		"no-tz-nano":          "1979-05-27T00:32:00.999999",
+		"no-tz-no-t":          "1979-05-27 07:32:00",
+		"no-tz-no-t-nano":     "1979-05-27 00:32:00.999999",
+		"date-no-tz":          "1979-05-27",
+		"time-no-tz":          "07:32:00",
+		"time-no-tz-nano":     "00:32:00.999999",
 	}
-	if dateRegexp.FindString("1979-05-27T00:32:00-07:00") == "" {
+
-		t.Error("offset lexing")
+	for name, value := range cases {
-	}
+		if dateRegexp.FindString(value) == "" {
-	if dateRegexp.FindString("1979-05-27T00:32:00.999999-07:00") == "" {
+			t.Error("failed date regexp test", name)
-		t.Error("nano precision lexing")
+		}
 	}
 	if dateRegexp.FindString("1979-05-27 07:32:00Z") == "" {
 		t.Error("space delimiter lexing")
@@ -735,6 +747,58 @@ func TestLexUnknownRvalue(t *testing.T) {
 	})
 }
 
+func TestLexInlineTableBareKey(t *testing.T) {
+	testFlow(t, `foo = { bar = "baz" }`, []token{
+		{Position{1, 1}, tokenKey, "foo"},
+		{Position{1, 5}, tokenEqual, "="},
+		{Position{1, 7}, tokenLeftCurlyBrace, "{"},
+		{Position{1, 9}, tokenKey, "bar"},
+		{Position{1, 13}, tokenEqual, "="},
+		{Position{1, 16}, tokenString, "baz"},
+		{Position{1, 21}, tokenRightCurlyBrace, "}"},
+		{Position{1, 22}, tokenEOF, ""},
+	})
+}
+
+func TestLexInlineTableBareKeyDash(t *testing.T) {
+	testFlow(t, `foo = { -bar = "baz" }`, []token{
+		{Position{1, 1}, tokenKey, "foo"},
+		{Position{1, 5}, tokenEqual, "="},
+		{Position{1, 7}, tokenLeftCurlyBrace, "{"},
+		{Position{1, 9}, tokenKey, "-bar"},
+		{Position{1, 14}, tokenEqual, "="},
+		{Position{1, 17}, tokenString, "baz"},
+		{Position{1, 22}, tokenRightCurlyBrace, "}"},
+		{Position{1, 23}, tokenEOF, ""},
+	})
+}
+
+func TestLexInlineTableBareKeyUnderscore(t *testing.T) {
+	testFlow(t, `foo = { _bar = "baz" }`, []token{
+		{Position{1, 1}, tokenKey, "foo"},
+		{Position{1, 5}, tokenEqual, "="},
+		{Position{1, 7}, tokenLeftCurlyBrace, "{"},
+		{Position{1, 9}, tokenKey, "_bar"},
+		{Position{1, 14}, tokenEqual, "="},
+		{Position{1, 17}, tokenString, "baz"},
+		{Position{1, 22}, tokenRightCurlyBrace, "}"},
+		{Position{1, 23}, tokenEOF, ""},
+	})
+}
+
+func TestLexInlineTableQuotedKey(t *testing.T) {
+	testFlow(t, `foo = { "bar" = "baz" }`, []token{
+		{Position{1, 1}, tokenKey, "foo"},
+		{Position{1, 5}, tokenEqual, "="},
+		{Position{1, 7}, tokenLeftCurlyBrace, "{"},
+		{Position{1, 9}, tokenKey, "\"bar\""},
+		{Position{1, 15}, tokenEqual, "="},
+		{Position{1, 18}, tokenString, "baz"},
+		{Position{1, 23}, tokenRightCurlyBrace, "}"},
+		{Position{1, 24}, tokenEOF, ""},
+	})
+}
+
 func BenchmarkLexer(b *testing.B) {
 	sample := `title = "Hugo: A Fast and Flexible Website Generator"
 baseurl = "http://gohugo.io/"

localtime.go

@@ -0,0 +1,281 @@
+// Implementation of TOML's local date/time.
+// Copied over from https://github.com/googleapis/google-cloud-go/blob/master/civil/civil.go
+// to avoid pulling all the Google dependencies.
+//
+// Copyright 2016 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package civil implements types for civil time, a time-zone-independent
+// representation of time that follows the rules of the proleptic
+// Gregorian calendar with exactly 24-hour days, 60-minute hours, and 60-second
+// minutes.
+//
+// Because they lack location information, these types do not represent unique
+// moments or intervals of time. Use time.Time for that purpose.
+package toml
+
+import (
+	"fmt"
+	"time"
+)
+
+// A LocalDate represents a date (year, month, day).
+//
+// This type does not include location information, and therefore does not
+// describe a unique 24-hour timespan.
+type LocalDate struct {
+	Year  int        // Year (e.g., 2014).
+	Month time.Month // Month of the year (January = 1, ...).
+	Day   int        // Day of the month, starting at 1.
+}
+
+// LocalDateOf returns the LocalDate in which a time occurs in that time's location.
+func LocalDateOf(t time.Time) LocalDate {
+	var d LocalDate
+	d.Year, d.Month, d.Day = t.Date()
+	return d
+}
+
+// ParseLocalDate parses a string in RFC3339 full-date format and returns the date value it represents.
+func ParseLocalDate(s string) (LocalDate, error) {
+	t, err := time.Parse("2006-01-02", s)
+	if err != nil {
+		return LocalDate{}, err
+	}
+	return LocalDateOf(t), nil
+}
+
+// String returns the date in RFC3339 full-date format.
+func (d LocalDate) String() string {
+	return fmt.Sprintf("%04d-%02d-%02d", d.Year, d.Month, d.Day)
+}
+
+// IsValid reports whether the date is valid.
+func (d LocalDate) IsValid() bool {
+	return LocalDateOf(d.In(time.UTC)) == d
+}
+
+// In returns the time corresponding to time 00:00:00 of the date in the location.
+//
+// In is always consistent with time.LocalDate, even when time.LocalDate returns a time
+// on a different day. For example, if loc is America/Indiana/Vincennes, then both
+//     time.LocalDate(1955, time.May, 1, 0, 0, 0, 0, loc)
+// and
+//     civil.LocalDate{Year: 1955, Month: time.May, Day: 1}.In(loc)
+// return 23:00:00 on April 30, 1955.
+//
+// In panics if loc is nil.
+func (d LocalDate) In(loc *time.Location) time.Time {
+	return time.Date(d.Year, d.Month, d.Day, 0, 0, 0, 0, loc)
+}
+
+// AddDays returns the date that is n days in the future.
+// n can also be negative to go into the past.
+func (d LocalDate) AddDays(n int) LocalDate {
+	return LocalDateOf(d.In(time.UTC).AddDate(0, 0, n))
+}
+
+// DaysSince returns the signed number of days between the date and s, not including the end day.
+// This is the inverse operation to AddDays.
+func (d LocalDate) DaysSince(s LocalDate) (days int) {
+	// We convert to Unix time so we do not have to worry about leap seconds:
+	// Unix time increases by exactly 86400 seconds per day.
+	deltaUnix := d.In(time.UTC).Unix() - s.In(time.UTC).Unix()
+	return int(deltaUnix / 86400)
+}
+
+// Before reports whether d1 occurs before d2.
+func (d1 LocalDate) Before(d2 LocalDate) bool {
+	if d1.Year != d2.Year {
+		return d1.Year < d2.Year
+	}
+	if d1.Month != d2.Month {
+		return d1.Month < d2.Month
+	}
+	return d1.Day < d2.Day
+}
+
+// After reports whether d1 occurs after d2.
+func (d1 LocalDate) After(d2 LocalDate) bool {
+	return d2.Before(d1)
+}
+
+// MarshalText implements the encoding.TextMarshaler interface.
+// The output is the result of d.String().
+func (d LocalDate) MarshalText() ([]byte, error) {
+	return []byte(d.String()), nil
+}
+
+// UnmarshalText implements the encoding.TextUnmarshaler interface.
+// The date is expected to be a string in a format accepted by ParseLocalDate.
+func (d *LocalDate) UnmarshalText(data []byte) error {
+	var err error
+	*d, err = ParseLocalDate(string(data))
+	return err
+}
+
+// A LocalTime represents a time with nanosecond precision.
+//
+// This type does not include location information, and therefore does not
+// describe a unique moment in time.
+//
+// This type exists to represent the TIME type in storage-based APIs like BigQuery.
+// Most operations on Times are unlikely to be meaningful. Prefer the LocalDateTime type.
+type LocalTime struct {
+	Hour       int // The hour of the day in 24-hour format; range [0-23]
+	Minute     int // The minute of the hour; range [0-59]
+	Second     int // The second of the minute; range [0-59]
+	Nanosecond int // The nanosecond of the second; range [0-999999999]
+}
+
+// LocalTimeOf returns the LocalTime representing the time of day in which a time occurs
+// in that time's location. It ignores the date.
+func LocalTimeOf(t time.Time) LocalTime {
+	var tm LocalTime
+	tm.Hour, tm.Minute, tm.Second = t.Clock()
+	tm.Nanosecond = t.Nanosecond()
+	return tm
+}
+
+// ParseLocalTime parses a string and returns the time value it represents.
+// ParseLocalTime accepts an extended form of the RFC3339 partial-time format. After
+// the HH:MM:SS part of the string, an optional fractional part may appear,
+// consisting of a decimal point followed by one to nine decimal digits.
+// (RFC3339 admits only one digit after the decimal point).
+func ParseLocalTime(s string) (LocalTime, error) {
+	t, err := time.Parse("15:04:05.999999999", s)
+	if err != nil {
+		return LocalTime{}, err
+	}
+	return LocalTimeOf(t), nil
+}
+
+// String returns the date in the format described in ParseLocalTime. If Nanoseconds
+// is zero, no fractional part will be generated. Otherwise, the result will
+// end with a fractional part consisting of a decimal point and nine digits.
+func (t LocalTime) String() string {
+	s := fmt.Sprintf("%02d:%02d:%02d", t.Hour, t.Minute, t.Second)
+	if t.Nanosecond == 0 {
+		return s
+	}
+	return s + fmt.Sprintf(".%09d", t.Nanosecond)
+}
+
+// IsValid reports whether the time is valid.
+func (t LocalTime) IsValid() bool {
+	// Construct a non-zero time.
+	tm := time.Date(2, 2, 2, t.Hour, t.Minute, t.Second, t.Nanosecond, time.UTC)
+	return LocalTimeOf(tm) == t
+}
+
+// MarshalText implements the encoding.TextMarshaler interface.
+// The output is the result of t.String().
+func (t LocalTime) MarshalText() ([]byte, error) {
+	return []byte(t.String()), nil
+}
+
+// UnmarshalText implements the encoding.TextUnmarshaler interface.
+// The time is expected to be a string in a format accepted by ParseLocalTime.
+func (t *LocalTime) UnmarshalText(data []byte) error {
+	var err error
+	*t, err = ParseLocalTime(string(data))
+	return err
+}
+
+// A LocalDateTime represents a date and time.
+//
+// This type does not include location information, and therefore does not
+// describe a unique moment in time.
+type LocalDateTime struct {
+	Date LocalDate
+	Time LocalTime
+}
+
+// Note: We deliberately do not embed LocalDate into LocalDateTime, to avoid promoting AddDays and Sub.
+
+// LocalDateTimeOf returns the LocalDateTime in which a time occurs in that time's location.
+func LocalDateTimeOf(t time.Time) LocalDateTime {
+	return LocalDateTime{
+		Date: LocalDateOf(t),
+		Time: LocalTimeOf(t),
+	}
+}
+
+// ParseLocalDateTime parses a string and returns the LocalDateTime it represents.
+// ParseLocalDateTime accepts a variant of the RFC3339 date-time format that omits
+// the time offset but includes an optional fractional time, as described in
+// ParseLocalTime. Informally, the accepted format is
+//     YYYY-MM-DDTHH:MM:SS[.FFFFFFFFF]
+// where the 'T' may be a lower-case 't'.
+func ParseLocalDateTime(s string) (LocalDateTime, error) {
+	t, err := time.Parse("2006-01-02T15:04:05.999999999", s)
+	if err != nil {
+		t, err = time.Parse("2006-01-02t15:04:05.999999999", s)
+		if err != nil {
+			return LocalDateTime{}, err
+		}
+	}
+	return LocalDateTimeOf(t), nil
+}
+
+// String returns the date in the format described in ParseLocalDate.
+func (dt LocalDateTime) String() string {
+	return dt.Date.String() + "T" + dt.Time.String()
+}
+
+// IsValid reports whether the datetime is valid.
+func (dt LocalDateTime) IsValid() bool {
+	return dt.Date.IsValid() && dt.Time.IsValid()
+}
+
+// In returns the time corresponding to the LocalDateTime in the given location.
+//
+// If the time is missing or ambigous at the location, In returns the same
+// result as time.LocalDate. For example, if loc is America/Indiana/Vincennes, then
+// both
+//     time.LocalDate(1955, time.May, 1, 0, 30, 0, 0, loc)
+// and
+//     civil.LocalDateTime{
+//         civil.LocalDate{Year: 1955, Month: time.May, Day: 1}},
+//         civil.LocalTime{Minute: 30}}.In(loc)
+// return 23:30:00 on April 30, 1955.
+//
+// In panics if loc is nil.
+func (dt LocalDateTime) In(loc *time.Location) time.Time {
+	return time.Date(dt.Date.Year, dt.Date.Month, dt.Date.Day, dt.Time.Hour, dt.Time.Minute, dt.Time.Second, dt.Time.Nanosecond, loc)
+}
+
+// Before reports whether dt1 occurs before dt2.
+func (dt1 LocalDateTime) Before(dt2 LocalDateTime) bool {
+	return dt1.In(time.UTC).Before(dt2.In(time.UTC))
+}
+
+// After reports whether dt1 occurs after dt2.
+func (dt1 LocalDateTime) After(dt2 LocalDateTime) bool {
+	return dt2.Before(dt1)
+}
+
+// MarshalText implements the encoding.TextMarshaler interface.
+// The output is the result of dt.String().
+func (dt LocalDateTime) MarshalText() ([]byte, error) {
+	return []byte(dt.String()), nil
+}
+
+// UnmarshalText implements the encoding.TextUnmarshaler interface.
+// The datetime is expected to be a string in a format accepted by ParseLocalDateTime
+func (dt *LocalDateTime) UnmarshalText(data []byte) error {
+	var err error
+	*dt, err = ParseLocalDateTime(string(data))
+	return err
+}

localtime_test.go

@@ -0,0 +1,446 @@
+// Copyright 2016 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package toml
+
+import (
+	"encoding/json"
+	"reflect"
+	"testing"
+	"time"
+)
+
+func cmpEqual(x, y interface{}) bool {
+	return reflect.DeepEqual(x, y)
+}
+
+func TestDates(t *testing.T) {
+	for _, test := range []struct {
+		date     LocalDate
+		loc      *time.Location
+		wantStr  string
+		wantTime time.Time
+	}{
+		{
+			date:     LocalDate{2014, 7, 29},
+			loc:      time.Local,
+			wantStr:  "2014-07-29",
+			wantTime: time.Date(2014, time.July, 29, 0, 0, 0, 0, time.Local),
+		},
+		{
+			date:     LocalDateOf(time.Date(2014, 8, 20, 15, 8, 43, 1, time.Local)),
+			loc:      time.UTC,
+			wantStr:  "2014-08-20",
+			wantTime: time.Date(2014, 8, 20, 0, 0, 0, 0, time.UTC),
+		},
+		{
+			date:     LocalDateOf(time.Date(999, time.January, 26, 0, 0, 0, 0, time.Local)),
+			loc:      time.UTC,
+			wantStr:  "0999-01-26",
+			wantTime: time.Date(999, 1, 26, 0, 0, 0, 0, time.UTC),
+		},
+	} {
+		if got := test.date.String(); got != test.wantStr {
+			t.Errorf("%#v.String() = %q, want %q", test.date, got, test.wantStr)
+		}
+		if got := test.date.In(test.loc); !got.Equal(test.wantTime) {
+			t.Errorf("%#v.In(%v) = %v, want %v", test.date, test.loc, got, test.wantTime)
+		}
+	}
+}
+
+func TestDateIsValid(t *testing.T) {
+	for _, test := range []struct {
+		date LocalDate
+		want bool
+	}{
+		{LocalDate{2014, 7, 29}, true},
+		{LocalDate{2000, 2, 29}, true},
+		{LocalDate{10000, 12, 31}, true},
+		{LocalDate{1, 1, 1}, true},
+		{LocalDate{0, 1, 1}, true},  // year zero is OK
+		{LocalDate{-1, 1, 1}, true}, // negative year is OK
+		{LocalDate{1, 0, 1}, false},
+		{LocalDate{1, 1, 0}, false},
+		{LocalDate{2016, 1, 32}, false},
+		{LocalDate{2016, 13, 1}, false},
+		{LocalDate{1, -1, 1}, false},
+		{LocalDate{1, 1, -1}, false},
+	} {
+		got := test.date.IsValid()
+		if got != test.want {
+			t.Errorf("%#v: got %t, want %t", test.date, got, test.want)
+		}
+	}
+}
+
+func TestParseDate(t *testing.T) {
+	for _, test := range []struct {
+		str  string
+		want LocalDate // if empty, expect an error
+	}{
+		{"2016-01-02", LocalDate{2016, 1, 2}},
+		{"2016-12-31", LocalDate{2016, 12, 31}},
+		{"0003-02-04", LocalDate{3, 2, 4}},
+		{"999-01-26", LocalDate{}},
+		{"", LocalDate{}},
+		{"2016-01-02x", LocalDate{}},
+	} {
+		got, err := ParseLocalDate(test.str)
+		if got != test.want {
+			t.Errorf("ParseLocalDate(%q) = %+v, want %+v", test.str, got, test.want)
+		}
+		if err != nil && test.want != (LocalDate{}) {
+			t.Errorf("Unexpected error %v from ParseLocalDate(%q)", err, test.str)
+		}
+	}
+}
+
+func TestDateArithmetic(t *testing.T) {
+	for _, test := range []struct {
+		desc  string
+		start LocalDate
+		end   LocalDate
+		days  int
+	}{
+		{
+			desc:  "zero days noop",
+			start: LocalDate{2014, 5, 9},
+			end:   LocalDate{2014, 5, 9},
+			days:  0,
+		},
+		{
+			desc:  "crossing a year boundary",
+			start: LocalDate{2014, 12, 31},
+			end:   LocalDate{2015, 1, 1},
+			days:  1,
+		},
+		{
+			desc:  "negative number of days",
+			start: LocalDate{2015, 1, 1},
+			end:   LocalDate{2014, 12, 31},
+			days:  -1,
+		},
+		{
+			desc:  "full leap year",
+			start: LocalDate{2004, 1, 1},
+			end:   LocalDate{2005, 1, 1},
+			days:  366,
+		},
+		{
+			desc:  "full non-leap year",
+			start: LocalDate{2001, 1, 1},
+			end:   LocalDate{2002, 1, 1},
+			days:  365,
+		},
+		{
+			desc:  "crossing a leap second",
+			start: LocalDate{1972, 6, 30},
+			end:   LocalDate{1972, 7, 1},
+			days:  1,
+		},
+		{
+			desc:  "dates before the unix epoch",
+			start: LocalDate{101, 1, 1},
+			end:   LocalDate{102, 1, 1},
+			days:  365,
+		},
+	} {
+		if got := test.start.AddDays(test.days); got != test.end {
+			t.Errorf("[%s] %#v.AddDays(%v) = %#v, want %#v", test.desc, test.start, test.days, got, test.end)
+		}
+		if got := test.end.DaysSince(test.start); got != test.days {
+			t.Errorf("[%s] %#v.Sub(%#v) = %v, want %v", test.desc, test.end, test.start, got, test.days)
+		}
+	}
+}
+
+func TestDateBefore(t *testing.T) {
+	for _, test := range []struct {
+		d1, d2 LocalDate
+		want   bool
+	}{
+		{LocalDate{2016, 12, 31}, LocalDate{2017, 1, 1}, true},
+		{LocalDate{2016, 1, 1}, LocalDate{2016, 1, 1}, false},
+		{LocalDate{2016, 12, 30}, LocalDate{2016, 12, 31}, true},
+		{LocalDate{2016, 1, 30}, LocalDate{2016, 12, 31}, true},
+	} {
+		if got := test.d1.Before(test.d2); got != test.want {
+			t.Errorf("%v.Before(%v): got %t, want %t", test.d1, test.d2, got, test.want)
+		}
+	}
+}
+
+func TestDateAfter(t *testing.T) {
+	for _, test := range []struct {
+		d1, d2 LocalDate
+		want   bool
+	}{
+		{LocalDate{2016, 12, 31}, LocalDate{2017, 1, 1}, false},
+		{LocalDate{2016, 1, 1}, LocalDate{2016, 1, 1}, false},
+		{LocalDate{2016, 12, 30}, LocalDate{2016, 12, 31}, false},
+	} {
+		if got := test.d1.After(test.d2); got != test.want {
+			t.Errorf("%v.After(%v): got %t, want %t", test.d1, test.d2, got, test.want)
+		}
+	}
+}
+
+func TestTimeToString(t *testing.T) {
+	for _, test := range []struct {
+		str       string
+		time      LocalTime
+		roundTrip bool // ParseLocalTime(str).String() == str?
+	}{
+		{"13:26:33", LocalTime{13, 26, 33, 0}, true},
+		{"01:02:03.000023456", LocalTime{1, 2, 3, 23456}, true},
+		{"00:00:00.000000001", LocalTime{0, 0, 0, 1}, true},
+		{"13:26:03.1", LocalTime{13, 26, 3, 100000000}, false},
+		{"13:26:33.0000003", LocalTime{13, 26, 33, 300}, false},
+	} {
+		gotTime, err := ParseLocalTime(test.str)
+		if err != nil {
+			t.Errorf("ParseLocalTime(%q): got error: %v", test.str, err)
+			continue
+		}
+		if gotTime != test.time {
+			t.Errorf("ParseLocalTime(%q) = %+v, want %+v", test.str, gotTime, test.time)
+		}
+		if test.roundTrip {
+			gotStr := test.time.String()
+			if gotStr != test.str {
+				t.Errorf("%#v.String() = %q, want %q", test.time, gotStr, test.str)
+			}
+		}
+	}
+}
+
+func TestTimeOf(t *testing.T) {
+	for _, test := range []struct {
+		time time.Time
+		want LocalTime
+	}{
+		{time.Date(2014, 8, 20, 15, 8, 43, 1, time.Local), LocalTime{15, 8, 43, 1}},
+		{time.Date(1, 1, 1, 0, 0, 0, 0, time.UTC), LocalTime{0, 0, 0, 0}},
+	} {
+		if got := LocalTimeOf(test.time); got != test.want {
+			t.Errorf("LocalTimeOf(%v) = %+v, want %+v", test.time, got, test.want)
+		}
+	}
+}
+
+func TestTimeIsValid(t *testing.T) {
+	for _, test := range []struct {
+		time LocalTime
+		want bool
+	}{
+		{LocalTime{0, 0, 0, 0}, true},
+		{LocalTime{23, 0, 0, 0}, true},
+		{LocalTime{23, 59, 59, 999999999}, true},
+		{LocalTime{24, 59, 59, 999999999}, false},
+		{LocalTime{23, 60, 59, 999999999}, false},
+		{LocalTime{23, 59, 60, 999999999}, false},
+		{LocalTime{23, 59, 59, 1000000000}, false},
+		{LocalTime{-1, 0, 0, 0}, false},
+		{LocalTime{0, -1, 0, 0}, false},
+		{LocalTime{0, 0, -1, 0}, false},
+		{LocalTime{0, 0, 0, -1}, false},
+	} {
+		got := test.time.IsValid()
+		if got != test.want {
+			t.Errorf("%#v: got %t, want %t", test.time, got, test.want)
+		}
+	}
+}
+
+func TestDateTimeToString(t *testing.T) {
+	for _, test := range []struct {
+		str       string
+		dateTime  LocalDateTime
+		roundTrip bool // ParseLocalDateTime(str).String() == str?
+	}{
+		{"2016-03-22T13:26:33", LocalDateTime{LocalDate{2016, 03, 22}, LocalTime{13, 26, 33, 0}}, true},
+		{"2016-03-22T13:26:33.000000600", LocalDateTime{LocalDate{2016, 03, 22}, LocalTime{13, 26, 33, 600}}, true},
+		{"2016-03-22t13:26:33", LocalDateTime{LocalDate{2016, 03, 22}, LocalTime{13, 26, 33, 0}}, false},
+	} {
+		gotDateTime, err := ParseLocalDateTime(test.str)
+		if err != nil {
+			t.Errorf("ParseLocalDateTime(%q): got error: %v", test.str, err)
+			continue
+		}
+		if gotDateTime != test.dateTime {
+			t.Errorf("ParseLocalDateTime(%q) = %+v, want %+v", test.str, gotDateTime, test.dateTime)
+		}
+		if test.roundTrip {
+			gotStr := test.dateTime.String()
+			if gotStr != test.str {
+				t.Errorf("%#v.String() = %q, want %q", test.dateTime, gotStr, test.str)
+			}
+		}
+	}
+}
+
+func TestParseDateTimeErrors(t *testing.T) {
+	for _, str := range []string{
+		"",
+		"2016-03-22",           // just a date
+		"13:26:33",             // just a time
+		"2016-03-22 13:26:33",  // wrong separating character
+		"2016-03-22T13:26:33x", // extra at end
+	} {
+		if _, err := ParseLocalDateTime(str); err == nil {
+			t.Errorf("ParseLocalDateTime(%q) succeeded, want error", str)
+		}
+	}
+}
+
+func TestDateTimeOf(t *testing.T) {
+	for _, test := range []struct {
+		time time.Time
+		want LocalDateTime
+	}{
+		{time.Date(2014, 8, 20, 15, 8, 43, 1, time.Local),
+			LocalDateTime{LocalDate{2014, 8, 20}, LocalTime{15, 8, 43, 1}}},
+		{time.Date(1, 1, 1, 0, 0, 0, 0, time.UTC),
+			LocalDateTime{LocalDate{1, 1, 1}, LocalTime{0, 0, 0, 0}}},
+	} {
+		if got := LocalDateTimeOf(test.time); got != test.want {
+			t.Errorf("LocalDateTimeOf(%v) = %+v, want %+v", test.time, got, test.want)
+		}
+	}
+}
+
+func TestDateTimeIsValid(t *testing.T) {
+	// No need to be exhaustive here; it's just LocalDate.IsValid && LocalTime.IsValid.
+	for _, test := range []struct {
+		dt   LocalDateTime
+		want bool
+	}{
+		{LocalDateTime{LocalDate{2016, 3, 20}, LocalTime{0, 0, 0, 0}}, true},
+		{LocalDateTime{LocalDate{2016, -3, 20}, LocalTime{0, 0, 0, 0}}, false},
+		{LocalDateTime{LocalDate{2016, 3, 20}, LocalTime{24, 0, 0, 0}}, false},
+	} {
+		got := test.dt.IsValid()
+		if got != test.want {
+			t.Errorf("%#v: got %t, want %t", test.dt, got, test.want)
+		}
+	}
+}
+
+func TestDateTimeIn(t *testing.T) {
+	dt := LocalDateTime{LocalDate{2016, 1, 2}, LocalTime{3, 4, 5, 6}}
+	got := dt.In(time.UTC)
+	want := time.Date(2016, 1, 2, 3, 4, 5, 6, time.UTC)
+	if !got.Equal(want) {
+		t.Errorf("got %v, want %v", got, want)
+	}
+}
+
+func TestDateTimeBefore(t *testing.T) {
+	d1 := LocalDate{2016, 12, 31}
+	d2 := LocalDate{2017, 1, 1}
+	t1 := LocalTime{5, 6, 7, 8}
+	t2 := LocalTime{5, 6, 7, 9}
+	for _, test := range []struct {
+		dt1, dt2 LocalDateTime
+		want     bool
+	}{
+		{LocalDateTime{d1, t1}, LocalDateTime{d2, t1}, true},
+		{LocalDateTime{d1, t1}, LocalDateTime{d1, t2}, true},
+		{LocalDateTime{d2, t1}, LocalDateTime{d1, t1}, false},
+		{LocalDateTime{d2, t1}, LocalDateTime{d2, t1}, false},
+	} {
+		if got := test.dt1.Before(test.dt2); got != test.want {
+			t.Errorf("%v.Before(%v): got %t, want %t", test.dt1, test.dt2, got, test.want)
+		}
+	}
+}
+
+func TestDateTimeAfter(t *testing.T) {
+	d1 := LocalDate{2016, 12, 31}
+	d2 := LocalDate{2017, 1, 1}
+	t1 := LocalTime{5, 6, 7, 8}
+	t2 := LocalTime{5, 6, 7, 9}
+	for _, test := range []struct {
+		dt1, dt2 LocalDateTime
+		want     bool
+	}{
+		{LocalDateTime{d1, t1}, LocalDateTime{d2, t1}, false},
+		{LocalDateTime{d1, t1}, LocalDateTime{d1, t2}, false},
+		{LocalDateTime{d2, t1}, LocalDateTime{d1, t1}, true},
+		{LocalDateTime{d2, t1}, LocalDateTime{d2, t1}, false},
+	} {
+		if got := test.dt1.After(test.dt2); got != test.want {
+			t.Errorf("%v.After(%v): got %t, want %t", test.dt1, test.dt2, got, test.want)
+		}
+	}
+}
+
+func TestMarshalJSON(t *testing.T) {
+	for _, test := range []struct {
+		value interface{}
+		want  string
+	}{
+		{LocalDate{1987, 4, 15}, `"1987-04-15"`},
+		{LocalTime{18, 54, 2, 0}, `"18:54:02"`},
+		{LocalDateTime{LocalDate{1987, 4, 15}, LocalTime{18, 54, 2, 0}}, `"1987-04-15T18:54:02"`},
+	} {
+		bgot, err := json.Marshal(test.value)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if got := string(bgot); got != test.want {
+			t.Errorf("%#v: got %s, want %s", test.value, got, test.want)
+		}
+	}
+}
+
+func TestUnmarshalJSON(t *testing.T) {
+	var d LocalDate
+	var tm LocalTime
+	var dt LocalDateTime
+	for _, test := range []struct {
+		data string
+		ptr  interface{}
+		want interface{}
+	}{
+		{`"1987-04-15"`, &d, &LocalDate{1987, 4, 15}},
+		{`"1987-04-\u0031\u0035"`, &d, &LocalDate{1987, 4, 15}},
+		{`"18:54:02"`, &tm, &LocalTime{18, 54, 2, 0}},
+		{`"1987-04-15T18:54:02"`, &dt, &LocalDateTime{LocalDate{1987, 4, 15}, LocalTime{18, 54, 2, 0}}},
+	} {
+		if err := json.Unmarshal([]byte(test.data), test.ptr); err != nil {
+			t.Fatalf("%s: %v", test.data, err)
+		}
+		if !cmpEqual(test.ptr, test.want) {
+			t.Errorf("%s: got %#v, want %#v", test.data, test.ptr, test.want)
+		}
+	}
+
+	for _, bad := range []string{"", `""`, `"bad"`, `"1987-04-15x"`,
+		`19870415`,     // a JSON number
+		`11987-04-15x`, // not a JSON string
+
+	} {
+		if json.Unmarshal([]byte(bad), &d) == nil {
+			t.Errorf("%q, LocalDate: got nil, want error", bad)
+		}
+		if json.Unmarshal([]byte(bad), &tm) == nil {
+			t.Errorf("%q, LocalTime: got nil, want error", bad)
+		}
+		if json.Unmarshal([]byte(bad), &dt) == nil {
+			t.Errorf("%q, LocalDateTime: got nil, want error", bad)
+		}
+	}
+}

marshal.go

@@ -68,6 +68,9 @@ const (
 
 var timeType = reflect.TypeOf(time.Time{})
 var marshalerType = reflect.TypeOf(new(Marshaler)).Elem()
+var localDateType = reflect.TypeOf(LocalDate{})
+var localTimeType = reflect.TypeOf(LocalTime{})
+var localDateTimeType = reflect.TypeOf(LocalDateTime{})
 
 // Check if the given marshal type maps to a Tree primitive
 func isPrimitive(mtype reflect.Type) bool {
@@ -85,29 +88,31 @@ func isPrimitive(mtype reflect.Type) bool {
 	case reflect.String:
 		return true
 	case reflect.Struct:
-		return mtype == timeType || isCustomMarshaler(mtype)
+		return mtype == timeType || mtype == localDateType || mtype == localDateTimeType || mtype == localTimeType || isCustomMarshaler(mtype)
 	default:
 		return false
 	}
 }
 
-// Check if the given marshal type maps to a Tree slice
+// Check if the given marshal type maps to a Tree slice or array
-func isTreeSlice(mtype reflect.Type) bool {
+func isTreeSequence(mtype reflect.Type) bool {
-	switch mtype.Kind() {
-	case reflect.Slice:
-		return !isOtherSlice(mtype)
-	default:
-		return false
-	}
-}
-
-// Check if the given marshal type maps to a non-Tree slice
-func isOtherSlice(mtype reflect.Type) bool {
 	switch mtype.Kind() {
 	case reflect.Ptr:
-		return isOtherSlice(mtype.Elem())
+		return isTreeSequence(mtype.Elem())
-	case reflect.Slice:
+	case reflect.Slice, reflect.Array:
-		return isPrimitive(mtype.Elem()) || isOtherSlice(mtype.Elem())
+		return isTree(mtype.Elem())
+	default:
+		return false
+	}
+}
+
+// Check if the given marshal type maps to a non-Tree slice or array
+func isOtherSequence(mtype reflect.Type) bool {
+	switch mtype.Kind() {
+	case reflect.Ptr:
+		return isOtherSequence(mtype.Elem())
+	case reflect.Slice, reflect.Array:
+		return !isTreeSequence(mtype)
 	default:
 		return false
 	}
@@ -116,6 +121,8 @@ func isOtherSlice(mtype reflect.Type) bool {
 // Check if the given marshal type maps to a Tree
 func isTree(mtype reflect.Type) bool {
 	switch mtype.Kind() {
+	case reflect.Ptr:
+		return isTree(mtype.Elem())
 	case reflect.Map:
 		return true
 	case reflect.Struct:
@@ -170,7 +177,7 @@ Tree primitive types and corresponding marshal types:
   float64    float32, float64, pointers to same
   string     string, pointers to same
   bool       bool, pointers to same
-  time.Time  time.Time{}, pointers to same
+  time.LocalTime  time.LocalTime{}, pointers to same
 
 For additional flexibility, use the Encoder API.
 */
@@ -406,9 +413,9 @@ func (e *Encoder) valueToToml(mtype reflect.Type, mval reflect.Value) (interface
 		return callCustomMarshaler(mval)
 	case isTree(mtype):
 		return e.valueToTree(mtype, mval)
-	case isTreeSlice(mtype):
+	case isTreeSequence(mtype):
 		return e.valueToTreeSlice(mtype, mval)
-	case isOtherSlice(mtype):
+	case isOtherSequence(mtype):
 		return e.valueToOtherSlice(mtype, mval)
 	default:
 		switch mtype.Kind() {
@@ -426,7 +433,7 @@ func (e *Encoder) valueToToml(mtype reflect.Type, mval reflect.Value) (interface
 		case reflect.String:
 			return mval.String(), nil
 		case reflect.Struct:
-			return mval.Interface().(time.Time), nil
+			return mval.Interface(), nil
 		default:
 			return nil, fmt.Errorf("Marshal can't handle %v(%v)", mtype, mtype.Kind())
 		}
@@ -687,12 +694,12 @@ func (d *Decoder) valueFromToml(mtype reflect.Type, tval interface{}, mval1 *ref
 		}
 		return reflect.ValueOf(nil), fmt.Errorf("Can't convert %v(%T) to a tree", tval, tval)
 	case []*Tree:
-		if isTreeSlice(mtype) {
+		if isTreeSequence(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) {
+		if isOtherSequence(mtype) {
 			return d.valueFromOtherSlice(mtype, t)
 		}
 		return reflect.ValueOf(nil), fmt.Errorf("Can't convert %v(%T) to a slice", tval, tval)
@@ -700,7 +707,31 @@ func (d *Decoder) valueFromToml(mtype reflect.Type, tval interface{}, mval1 *ref
 		switch mtype.Kind() {
 		case reflect.Bool, reflect.Struct:
 			val := reflect.ValueOf(tval)
-			// if this passes for when mtype is reflect.Struct, tval is a time.Time
+
+			switch val.Type() {
+			case localDateType:
+				localDate := val.Interface().(LocalDate)
+				switch mtype {
+				case timeType:
+					return reflect.ValueOf(time.Date(localDate.Year, localDate.Month, localDate.Day, 0, 0, 0, 0, time.Local)), nil
+				}
+			case localDateTimeType:
+				localDateTime := val.Interface().(LocalDateTime)
+				switch mtype {
+				case timeType:
+					return reflect.ValueOf(time.Date(
+						localDateTime.Date.Year,
+						localDateTime.Date.Month,
+						localDateTime.Date.Day,
+						localDateTime.Time.Hour,
+						localDateTime.Time.Minute,
+						localDateTime.Time.Second,
+						localDateTime.Time.Nanosecond,
+						time.Local)), nil
+				}
+			}
+
+			// if this passes for when mtype is reflect.Struct, tval is a time.LocalTime
 			if !val.Type().ConvertibleTo(mtype) {
 				return reflect.ValueOf(nil), fmt.Errorf("Can't convert %v(%T) to %v", tval, tval, mtype.String())
 			}

marshal_test.go

@@ -433,12 +433,36 @@ type tomlTypeCheckTest struct {
 
 func TestTypeChecks(t *testing.T) {
 	tests := []tomlTypeCheckTest{
-		{"integer", 2, 0},
+		{"bool", true, 0},
+		{"bool", false, 0},
+		{"int", int(2), 0},
+		{"int8", int8(2), 0},
+		{"int16", int16(2), 0},
+		{"int32", int32(2), 0},
+		{"int64", int64(2), 0},
+		{"uint", uint(2), 0},
+		{"uint8", uint8(2), 0},
+		{"uint16", uint16(2), 0},
+		{"uint32", uint32(2), 0},
+		{"uint64", uint64(2), 0},
+		{"float32", float32(3.14), 0},
+		{"float64", float64(3.14), 0},
+		{"string", "lorem ipsum", 0},
 		{"time", time.Date(2015, 1, 1, 0, 0, 0, 0, time.UTC), 0},
 		{"stringlist", []string{"hello", "hi"}, 1},
+		{"stringlistptr", &[]string{"hello", "hi"}, 1},
+		{"stringarray", [2]string{"hello", "hi"}, 1},
+		{"stringarrayptr", &[2]string{"hello", "hi"}, 1},
 		{"timelist", []time.Time{time.Date(2015, 1, 1, 0, 0, 0, 0, time.UTC)}, 1},
+		{"timelistptr", &[]time.Time{time.Date(2015, 1, 1, 0, 0, 0, 0, time.UTC)}, 1},
+		{"timearray", [1]time.Time{time.Date(2015, 1, 1, 0, 0, 0, 0, time.UTC)}, 1},
+		{"timearrayptr", &[1]time.Time{time.Date(2015, 1, 1, 0, 0, 0, 0, time.UTC)}, 1},
 		{"objectlist", []tomlTypeCheckTest{}, 2},
+		{"objectlistptr", &[]tomlTypeCheckTest{}, 2},
+		{"objectarray", [2]tomlTypeCheckTest{{}, {}}, 2},
+		{"objectlistptr", &[2]tomlTypeCheckTest{{}, {}}, 2},
 		{"object", tomlTypeCheckTest{}, 3},
+		{"objectptr", &tomlTypeCheckTest{}, 3},
 	}
 
 	for _, test := range tests {
@@ -446,8 +470,8 @@ func TestTypeChecks(t *testing.T) {
 		expected[test.typ] = true
 		result := []bool{
 			isPrimitive(reflect.TypeOf(test.item)),
-			isOtherSlice(reflect.TypeOf(test.item)),
+			isOtherSequence(reflect.TypeOf(test.item)),
-			isTreeSlice(reflect.TypeOf(test.item)),
+			isTreeSequence(reflect.TypeOf(test.item)),
 			isTree(reflect.TypeOf(test.item)),
 		}
 		if !reflect.DeepEqual(expected, result) {
@@ -1135,6 +1159,21 @@ func TestMarshalCustomCommented(t *testing.T) {
 	}
 }
 
+func TestMarshalDirectMultilineString(t *testing.T) {
+	tree := newTree()
+	tree.SetWithOptions("mykey", SetOptions{
+		Multiline: true,
+	}, "my\x11multiline\nstring\ba\tb\fc\rd\"e\\!")
+	result, err := tree.Marshal()
+	if err != nil {
+		t.Fatal("marshal should not error:", err)
+	}
+	expected := []byte("mykey = \"\"\"\nmy\\u0011multiline\nstring\\ba\tb\\fc\rd\"e\\!\"\"\"\n")
+	if !bytes.Equal(result, expected) {
+		t.Errorf("Bad marshal: expected\n-----\n%s\n-----\ngot\n-----\n%s\n-----\n", expected, result)
+	}
+}
+
 var customMultilineTagTestToml = []byte(`int_slice = [
   1,
   2,
@@ -1699,3 +1738,405 @@ func TestTreeMarshal(t *testing.T) {
 		})
 	}
 }
+
+func TestMarshalArrays(t *testing.T) {
+	cases := []struct {
+		Data     interface{}
+		Expected string
+	}{
+		{
+			Data: struct {
+				XY [2]int
+			}{
+				XY: [2]int{1, 2},
+			},
+			Expected: `XY = [1,2]
+`,
+		},
+		{
+			Data: struct {
+				XY [1][2]int
+			}{
+				XY: [1][2]int{{1, 2}},
+			},
+			Expected: `XY = [[1,2]]
+`,
+		},
+		{
+			Data: struct {
+				XY [1][]int
+			}{
+				XY: [1][]int{{1, 2}},
+			},
+			Expected: `XY = [[1,2]]
+`,
+		},
+		{
+			Data: struct {
+				XY [][2]int
+			}{
+				XY: [][2]int{{1, 2}},
+			},
+			Expected: `XY = [[1,2]]
+`,
+		},
+	}
+	for _, tc := range cases {
+		t.Run("", func(t *testing.T) {
+			result, err := Marshal(tc.Data)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !bytes.Equal(result, []byte(tc.Expected)) {
+				t.Errorf("Bad marshal: expected\n-----\n%s\n-----\ngot\n-----\n%s\n-----\n", []byte(tc.Expected), result)
+			}
+		})
+	}
+}
+
+func TestUnmarshalLocalDate(t *testing.T) {
+	t.Run("ToLocalDate", func(t *testing.T) {
+		type dateStruct struct {
+			Date LocalDate
+		}
+
+		toml := `date = 1979-05-27`
+
+		var obj dateStruct
+
+		err := Unmarshal([]byte(toml), &obj)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if obj.Date.Year != 1979 {
+			t.Errorf("expected year 1979, got %d", obj.Date.Year)
+		}
+		if obj.Date.Month != 5 {
+			t.Errorf("expected month 5, got %d", obj.Date.Month)
+		}
+		if obj.Date.Day != 27 {
+			t.Errorf("expected day 27, got %d", obj.Date.Day)
+		}
+	})
+
+	t.Run("ToLocalDate", func(t *testing.T) {
+		type dateStruct struct {
+			Date time.Time
+		}
+
+		toml := `date = 1979-05-27`
+
+		var obj dateStruct
+
+		err := Unmarshal([]byte(toml), &obj)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if obj.Date.Year() != 1979 {
+			t.Errorf("expected year 1979, got %d", obj.Date.Year())
+		}
+		if obj.Date.Month() != 5 {
+			t.Errorf("expected month 5, got %d", obj.Date.Month())
+		}
+		if obj.Date.Day() != 27 {
+			t.Errorf("expected day 27, got %d", obj.Date.Day())
+		}
+	})
+}
+
+func TestMarshalLocalDate(t *testing.T) {
+	type dateStruct struct {
+		Date LocalDate
+	}
+
+	obj := dateStruct{Date: LocalDate{
+		Year:  1979,
+		Month: 5,
+		Day:   27,
+	}}
+
+	b, err := Marshal(obj)
+
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	got := string(b)
+	expected := `Date = 1979-05-27
+`
+
+	if got != expected {
+		t.Errorf("expected '%s', got '%s'", expected, got)
+	}
+}
+
+func TestUnmarshalLocalDateTime(t *testing.T) {
+	examples := []struct {
+		name string
+		in   string
+		out  LocalDateTime
+	}{
+		{
+			name: "normal",
+			in:   "1979-05-27T07:32:00",
+			out: LocalDateTime{
+				Date: LocalDate{
+					Year:  1979,
+					Month: 5,
+					Day:   27,
+				},
+				Time: LocalTime{
+					Hour:       7,
+					Minute:     32,
+					Second:     0,
+					Nanosecond: 0,
+				},
+			}},
+		{
+			name: "with nanoseconds",
+			in:   "1979-05-27T00:32:00.999999",
+			out: LocalDateTime{
+				Date: LocalDate{
+					Year:  1979,
+					Month: 5,
+					Day:   27,
+				},
+				Time: LocalTime{
+					Hour:       0,
+					Minute:     32,
+					Second:     0,
+					Nanosecond: 999999000,
+				},
+			},
+		},
+	}
+
+	for i, example := range examples {
+		toml := fmt.Sprintf(`date = %s`, example.in)
+
+		t.Run(fmt.Sprintf("ToLocalDateTime_%d_%s", i, example.name), func(t *testing.T) {
+			type dateStruct struct {
+				Date LocalDateTime
+			}
+
+			var obj dateStruct
+
+			err := Unmarshal([]byte(toml), &obj)
+
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			if obj.Date != example.out {
+				t.Errorf("expected '%s', got '%s'", example.out, obj.Date)
+			}
+		})
+
+		t.Run(fmt.Sprintf("ToTime_%d_%s", i, example.name), func(t *testing.T) {
+			type dateStruct struct {
+				Date time.Time
+			}
+
+			var obj dateStruct
+
+			err := Unmarshal([]byte(toml), &obj)
+
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			if obj.Date.Year() != example.out.Date.Year {
+				t.Errorf("expected year %d, got %d", example.out.Date.Year, obj.Date.Year())
+			}
+			if obj.Date.Month() != example.out.Date.Month {
+				t.Errorf("expected month %d, got %d", example.out.Date.Month, obj.Date.Month())
+			}
+			if obj.Date.Day() != example.out.Date.Day {
+				t.Errorf("expected day %d, got %d", example.out.Date.Day, obj.Date.Day())
+			}
+			if obj.Date.Hour() != example.out.Time.Hour {
+				t.Errorf("expected hour %d, got %d", example.out.Time.Hour, obj.Date.Hour())
+			}
+			if obj.Date.Minute() != example.out.Time.Minute {
+				t.Errorf("expected minute %d, got %d", example.out.Time.Minute, obj.Date.Minute())
+			}
+			if obj.Date.Second() != example.out.Time.Second {
+				t.Errorf("expected second %d, got %d", example.out.Time.Second, obj.Date.Second())
+			}
+			if obj.Date.Nanosecond() != example.out.Time.Nanosecond {
+				t.Errorf("expected nanoseconds %d, got %d", example.out.Time.Nanosecond, obj.Date.Nanosecond())
+			}
+		})
+	}
+}
+
+func TestMarshalLocalDateTime(t *testing.T) {
+	type dateStruct struct {
+		DateTime LocalDateTime
+	}
+
+	examples := []struct {
+		name string
+		in   LocalDateTime
+		out  string
+	}{
+		{
+			name: "normal",
+			out:  "DateTime = 1979-05-27T07:32:00\n",
+			in: LocalDateTime{
+				Date: LocalDate{
+					Year:  1979,
+					Month: 5,
+					Day:   27,
+				},
+				Time: LocalTime{
+					Hour:       7,
+					Minute:     32,
+					Second:     0,
+					Nanosecond: 0,
+				},
+			}},
+		{
+			name: "with nanoseconds",
+			out:  "DateTime = 1979-05-27T00:32:00.999999000\n",
+			in: LocalDateTime{
+				Date: LocalDate{
+					Year:  1979,
+					Month: 5,
+					Day:   27,
+				},
+				Time: LocalTime{
+					Hour:       0,
+					Minute:     32,
+					Second:     0,
+					Nanosecond: 999999000,
+				},
+			},
+		},
+	}
+
+	for i, example := range examples {
+		t.Run(fmt.Sprintf("%d_%s", i, example.name), func(t *testing.T) {
+			obj := dateStruct{
+				DateTime: example.in,
+			}
+			b, err := Marshal(obj)
+
+			if err != nil {
+				t.Fatalf("unexpected error: %v", err)
+			}
+
+			got := string(b)
+
+			if got != example.out {
+				t.Errorf("expected '%s', got '%s'", example.out, got)
+			}
+		})
+	}
+}
+
+func TestUnmarshalLocalTime(t *testing.T) {
+	examples := []struct {
+		name string
+		in   string
+		out  LocalTime
+	}{
+		{
+			name: "normal",
+			in:   "07:32:00",
+			out: LocalTime{
+				Hour:       7,
+				Minute:     32,
+				Second:     0,
+				Nanosecond: 0,
+			},
+		},
+		{
+			name: "with nanoseconds",
+			in:   "00:32:00.999999",
+			out: LocalTime{
+				Hour:       0,
+				Minute:     32,
+				Second:     0,
+				Nanosecond: 999999000,
+			},
+		},
+	}
+
+	for i, example := range examples {
+		toml := fmt.Sprintf(`Time = %s`, example.in)
+
+		t.Run(fmt.Sprintf("ToLocalTime_%d_%s", i, example.name), func(t *testing.T) {
+			type dateStruct struct {
+				Time LocalTime
+			}
+
+			var obj dateStruct
+
+			err := Unmarshal([]byte(toml), &obj)
+
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			if obj.Time != example.out {
+				t.Errorf("expected '%s', got '%s'", example.out, obj.Time)
+			}
+		})
+	}
+}
+
+func TestMarshalLocalTime(t *testing.T) {
+	type timeStruct struct {
+		Time LocalTime
+	}
+
+	examples := []struct {
+		name string
+		in   LocalTime
+		out  string
+	}{
+		{
+			name: "normal",
+			out:  "Time = 07:32:00\n",
+			in: LocalTime{
+				Hour:       7,
+				Minute:     32,
+				Second:     0,
+				Nanosecond: 0,
+			}},
+		{
+			name: "with nanoseconds",
+			out:  "Time = 00:32:00.999999000\n",
+			in: LocalTime{
+				Hour:       0,
+				Minute:     32,
+				Second:     0,
+				Nanosecond: 999999000,
+			},
+		},
+	}
+
+	for i, example := range examples {
+		t.Run(fmt.Sprintf("%d_%s", i, example.name), func(t *testing.T) {
+			obj := timeStruct{
+				Time: example.in,
+			}
+			b, err := Marshal(obj)
+
+			if err != nil {
+				t.Fatalf("unexpected error: %v", err)
+			}
+
+			got := string(b)
+
+			if got != example.out {
+				t.Errorf("expected '%s', got '%s'", example.out, got)
+			}
+		})
+	}
+}

parser.go

@@ -318,6 +318,36 @@ func (p *tomlParser) parseRvalue() interface{} {
 			layout = strings.Replace(layout, "T", " ", 1)
 		}
 		val, err := time.ParseInLocation(layout, tok.val, time.UTC)
+		if err != nil {
+			p.raiseError(tok, "%s", err)
+		}
+		return val
+	case tokenLocalDate:
+		v := strings.Replace(tok.val, " ", "T", -1)
+		isDateTime := false
+		isTime := false
+		for _, c := range v {
+			if c == 'T' || c == 't' {
+				isDateTime = true
+				break
+			}
+			if c == ':' {
+				isTime = true
+				break
+			}
+		}
+
+		var val interface{}
+		var err error
+
+		if isDateTime {
+			val, err = ParseLocalDateTime(v)
+		} else if isTime {
+			val, err = ParseLocalTime(v)
+		} else {
+			val, err = ParseLocalDate(v)
+		}
+
 		if err != nil {
 			p.raiseError(tok, "%s", err)
 		}
@@ -360,12 +390,15 @@ Loop:
 			}
 			key := p.getToken()
 			p.assume(tokenEqual)
-			value := p.parseRvalue()
+
-			tree.Set(key.val, value)
+			parsedKey, err := parseKey(key.val)
-		case tokenComma:
+			if err != nil {
-			if previous == nil {
+				p.raiseError(key, "invalid key: %s", err)
-				p.raiseError(follow, "inline table cannot start with a comma")
 			}
+
+			value := p.parseRvalue()
+			tree.SetPath(parsedKey, value)
+		case tokenComma:
 			if tokenIsComma(previous) {
 				p.raiseError(follow, "need field between two commas in inline table")
 			}

parser_test.go

@@ -197,7 +197,7 @@ func TestFloatsWithExponents(t *testing.T) {
 	tree, err := Load("a = 5e+22\nb = 5E+22\nc = -5e+22\nd = -5e-22\ne = 6.626e-34")
 	assertTree(t, tree, err, map[string]interface{}{
 		"a": float64(5e+22),
-		"b": float64(5E+22),
+		"b": float64(5e+22),
 		"c": float64(-5e+22),
 		"d": float64(-5e-22),
 		"e": float64(6.626e-34),
@@ -225,10 +225,74 @@ func TestDateNano(t *testing.T) {
 	})
 }
 
-func TestDateSpaceDelimiter(t *testing.T) {
+func TestLocalDateTime(t *testing.T) {
-	tree, err := Load("odt4 = 1979-05-27 07:32:00Z")
+	tree, err := Load("a = 1979-05-27T07:32:00")
 	assertTree(t, tree, err, map[string]interface{}{
-		"odt4": time.Date(1979, time.May, 27, 7, 32, 0, 0, time.UTC),
+		"a": LocalDateTime{
+			Date: LocalDate{
+				Year:  1979,
+				Month: 5,
+				Day:   27,
+			},
+			Time: LocalTime{
+				Hour:       7,
+				Minute:     32,
+				Second:     0,
+				Nanosecond: 0,
+			}},
+	})
+}
+
+func TestLocalDateTimeNano(t *testing.T) {
+	tree, err := Load("a = 1979-05-27T07:32:00.999999")
+	assertTree(t, tree, err, map[string]interface{}{
+		"a": LocalDateTime{
+			Date: LocalDate{
+				Year:  1979,
+				Month: 5,
+				Day:   27,
+			},
+			Time: LocalTime{
+				Hour:       7,
+				Minute:     32,
+				Second:     0,
+				Nanosecond: 999999000,
+			}},
+	})
+}
+
+func TestLocalDate(t *testing.T) {
+	tree, err := Load("a = 1979-05-27")
+	assertTree(t, tree, err, map[string]interface{}{
+		"a": LocalDate{
+			Year:  1979,
+			Month: 5,
+			Day:   27,
+		},
+	})
+}
+
+func TestLocalTime(t *testing.T) {
+	tree, err := Load("a = 07:32:00")
+	assertTree(t, tree, err, map[string]interface{}{
+		"a": LocalTime{
+			Hour:       7,
+			Minute:     32,
+			Second:     0,
+			Nanosecond: 0,
+		},
+	})
+}
+
+func TestLocalTimeNano(t *testing.T) {
+	tree, err := Load("a = 00:32:00.999999")
+	assertTree(t, tree, err, map[string]interface{}{
+		"a": LocalTime{
+			Hour:       0,
+			Minute:     32,
+			Second:     0,
+			Nanosecond: 999999000,
+		},
 	})
 }
 
@@ -532,6 +596,33 @@ point = { x = 1, y = 2 }`)
 	})
 }
 
+func TestInlineGroupBareKeysUnderscore(t *testing.T) {
+	tree, err := Load(`foo = { _bar = "buz" }`)
+	assertTree(t, tree, err, map[string]interface{}{
+		"foo": map[string]interface{}{
+			"_bar": "buz",
+		},
+	})
+}
+
+func TestInlineGroupBareKeysDash(t *testing.T) {
+	tree, err := Load(`foo = { -bar = "buz" }`)
+	assertTree(t, tree, err, map[string]interface{}{
+		"foo": map[string]interface{}{
+			"-bar": "buz",
+		},
+	})
+}
+
+func TestInlineGroupKeyQuoted(t *testing.T) {
+	tree, err := Load(`foo = { "bar" = "buz" }`)
+	assertTree(t, tree, err, map[string]interface{}{
+		"foo": map[string]interface{}{
+			"bar": "buz",
+		},
+	})
+}
+
 func TestExampleInlineGroupInArray(t *testing.T) {
 	tree, err := Load(`points = [{ x = 1, y = 2 }]`)
 	assertTree(t, tree, err, map[string]interface{}{
@@ -560,7 +651,7 @@ func TestInlineTableCommaExpected(t *testing.T) {
 
 func TestInlineTableCommaStart(t *testing.T) {
 	_, err := Load("foo = {, hello = 53}")
-	if err.Error() != "(1, 8): inline table cannot start with a comma" {
+	if err.Error() != "(1, 8): unexpected token type in inline table: keys cannot contain , character" {
 		t.Error("Bad error message:", err.Error())
 	}
 }
@@ -916,6 +1007,13 @@ func TestMapKeyIsNum(t *testing.T) {
 	}
 }
 
+func TestInvalidKeyInlineTable(t *testing.T) {
+	_, err := Load("table={invalid..key = 1}")
+	if err.Error() != "(1, 8): invalid key: expecting key part after dot" {
+		t.Error("Bad error message:", err.Error())
+	}
+}
+
 func TestDottedKeys(t *testing.T) {
 	tree, err := Load(`
 name = "Orange"
@@ -944,3 +1042,40 @@ func TestInvalidDottedKeyEmptyGroup(t *testing.T) {
 		t.Fatalf("invalid error message: %s", err)
 	}
 }
+
+func TestAccidentalNewlines(t *testing.T) {
+	expected := "The quick brown fox jumps over the lazy dog."
+	tree, err := Load(`str1 = "The quick brown fox jumps over the lazy dog."
+
+str2 = """
+The quick brown \
+
+
+  fox jumps over \
+    the lazy dog."""
+
+str3 = """\
+       The quick brown \ 
+       fox jumps over \ 
+       the lazy dog.\  
+       """`)
+
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	got := tree.Get("str1")
+	if got != expected {
+		t.Errorf("expected '%s', got '%s'", expected, got)
+	}
+
+	got = tree.Get("str2")
+	if got != expected {
+		t.Errorf("expected '%s', got '%s'", expected, got)
+	}
+
+	got = tree.Get("str3")
+	if got != expected {
+		t.Errorf("expected '%s', got '%s'", expected, got)
+	}
+}

token.go

@@ -2,7 +2,6 @@ package toml
 
 import (
 	"fmt"
-	"strconv"
 	"unicode"
 )
 
@@ -35,6 +34,7 @@ const (
 	tokenDoubleLeftBracket
 	tokenDoubleRightBracket
 	tokenDate
+	tokenLocalDate
 	tokenKeyGroup
 	tokenKeyGroupArray
 	tokenComma
@@ -68,7 +68,8 @@ var tokenTypeNames = []string{
 	")",
 	"]]",
 	"[[",
-	"Date",
+	"LocalDate",
+	"LocalDate",
 	"KeyGroup",
 	"KeyGroupArray",
 	",",
@@ -95,14 +96,6 @@ func (tt tokenType) String() string {
 	return "Unknown"
 }
 
-func (t token) Int() int {
-	if result, err := strconv.Atoi(t.val); err != nil {
-		panic(err)
-	} else {
-		return result
-	}
-}
-
 func (t token) String() string {
 	switch t.typ {
 	case tokenEOF:

token_test.go

@@ -25,7 +25,8 @@ func TestTokenStringer(t *testing.T) {
 		{tokenRightParen, ")"},
 		{tokenDoubleLeftBracket, "]]"},
 		{tokenDoubleRightBracket, "[["},
-		{tokenDate, "Date"},
+		{tokenDate, "LocalDate"},
+		{tokenLocalDate, "LocalDate"},
 		{tokenKeyGroup, "KeyGroup"},
 		{tokenKeyGroupArray, "KeyGroupArray"},
 		{tokenComma, ","},

tomltree_write.go

@@ -136,6 +136,12 @@ func tomlValueStringRepresentation(v interface{}, indent string, arraysOneElemen
 		return "false", nil
 	case time.Time:
 		return value.Format(time.RFC3339), nil
+	case LocalDate:
+		return value.String(), nil
+	case LocalDateTime:
+		return value.String(), nil
+	case LocalTime:
+		return value.String(), nil
 	case nil:
 		return "", nil
 	}