diff --git a/lexer.go b/lexer.go index e075e09..735673b 100644 --- a/lexer.go +++ b/lexer.go @@ -223,9 +223,12 @@ func (l *tomlLexer) lexRvalue() tomlLexStateFn { } possibleDate := l.peekString(35) - dateMatch := dateRegexp.FindString(possibleDate) - if dateMatch != "" { - l.fastForward(len(dateMatch)) + dateSubmatches := dateRegexp.FindStringSubmatch(possibleDate) + if dateSubmatches != nil && dateSubmatches[0] != "" { + l.fastForward(len(dateSubmatches[0])) + if dateSubmatches[2] == "" { // no timezone information => local date + return l.lexLocalDate + } return l.lexDate } @@ -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 diff --git a/lexer_test.go b/lexer_test.go index e979f8a..6a33f57 100644 --- a/lexer_test.go +++ b/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") == "" { - t.Error("basic lexing") + cases := map[string]string{ + "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") - } - if dateRegexp.FindString("1979-05-27T00:32:00.999999-07:00") == "" { - t.Error("nano precision lexing") + + for name, value := range cases { + if dateRegexp.FindString(value) == "" { + t.Error("failed date regexp test", name) + } } if dateRegexp.FindString("1979-05-27 07:32:00Z") == "" { t.Error("space delimiter lexing") diff --git a/localtime.go b/localtime.go new file mode 100644 index 0000000..a2149e9 --- /dev/null +++ b/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 +} diff --git a/localtime_test.go b/localtime_test.go new file mode 100644 index 0000000..4bbb5b0 --- /dev/null +++ b/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) + } + } +} diff --git a/marshal.go b/marshal.go index 4155c40..03ff054 100644 --- a/marshal.go +++ b/marshal.go @@ -68,6 +68,7 @@ const ( var timeType = reflect.TypeOf(time.Time{}) var marshalerType = reflect.TypeOf(new(Marshaler)).Elem() +var localDateType = reflect.TypeOf(LocalDate{}) // Check if the given marshal type maps to a Tree primitive func isPrimitive(mtype reflect.Type) bool { @@ -85,7 +86,7 @@ func isPrimitive(mtype reflect.Type) bool { case reflect.String: return true case reflect.Struct: - return mtype == timeType || isCustomMarshaler(mtype) + return mtype == timeType || mtype == localDateType || isCustomMarshaler(mtype) default: return false } @@ -174,7 +175,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. */ @@ -430,7 +431,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()) } @@ -704,7 +705,16 @@ 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 + + if val.Type() == 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 + } + } + + // 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()) } diff --git a/marshal_test.go b/marshal_test.go index bfa7d00..9e24b09 100644 --- a/marshal_test.go +++ b/marshal_test.go @@ -1793,3 +1793,83 @@ func TestMarshalArrays(t *testing.T) { }) } } + +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) + } +} diff --git a/parser.go b/parser.go index 983e161..1b344fe 100644 --- a/parser.go +++ b/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) } diff --git a/parser_test.go b/parser_test.go index 97b2f22..01f37eb 100644 --- a/parser_test.go +++ b/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) { - tree, err := Load("odt4 = 1979-05-27 07:32:00Z") +func TestLocalDateTime(t *testing.T) { + 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, + }, }) } diff --git a/token.go b/token.go index 1072135..36a3fc8 100644 --- a/token.go +++ b/token.go @@ -34,6 +34,7 @@ const ( tokenDoubleLeftBracket tokenDoubleRightBracket tokenDate + tokenLocalDate tokenKeyGroup tokenKeyGroupArray tokenComma @@ -67,7 +68,8 @@ var tokenTypeNames = []string{ ")", "]]", "[[", - "Date", + "LocalDate", + "LocalDate", "KeyGroup", "KeyGroupArray", ",", diff --git a/token_test.go b/token_test.go index 20b560d..13aad28 100644 --- a/token_test.go +++ b/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, ","}, diff --git a/tomltree_write.go b/tomltree_write.go index 4c96d3b..ee35db4 100644 --- a/tomltree_write.go +++ b/tomltree_write.go @@ -136,6 +136,8 @@ 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 nil: return "", nil }