Short-date support (#298)
This commit is contained in:
Thomas Pelletier
@@ -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
|
||||
|
||||
+19
-7
@@ -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")
|
||||
|
||||
+281
@@ -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
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
}
|
||||
+14
-4
@@ -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())
|
||||
}
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
|
||||
+68
-4
@@ -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,
|
||||
},
|
||||
})
|
||||
}
|
||||
|
||||
|
||||
@@ -34,6 +34,7 @@ const (
|
||||
tokenDoubleLeftBracket
|
||||
tokenDoubleRightBracket
|
||||
tokenDate
|
||||
tokenLocalDate
|
||||
tokenKeyGroup
|
||||
tokenKeyGroupArray
|
||||
tokenComma
|
||||
@@ -67,7 +68,8 @@ var tokenTypeNames = []string{
|
||||
")",
|
||||
"]]",
|
||||
"[[",
|
||||
"Date",
|
||||
"LocalDate",
|
||||
"LocalDate",
|
||||
"KeyGroup",
|
||||
"KeyGroupArray",
|
||||
",",
|
||||
|
||||
+2
-1
@@ -25,7 +25,8 @@ func TestTokenStringer(t *testing.T) {
|
||||
{tokenRightParen, ")"},
|
||||
{tokenDoubleLeftBracket, "]]"},
|
||||
{tokenDoubleRightBracket, "[["},
|
||||
{tokenDate, "Date"},
|
||||
{tokenDate, "LocalDate"},
|
||||
{tokenLocalDate, "LocalDate"},
|
||||
{tokenKeyGroup, "KeyGroup"},
|
||||
{tokenKeyGroupArray, "KeyGroupArray"},
|
||||
{tokenComma, ","},
|
||||
|
||||
@@ -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
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user