From 5e65f9206bdb013b233bde6bac91fc88e00ff7a3 Mon Sep 17 00:00:00 2001 From: Dmitry Panov Date: Sun, 25 Nov 2018 12:58:30 +0000 Subject: [PATCH] Date.parse() now returns a number. Switched to own date parser for better compatibility (extended years, etc.). Fixes #79 --- builtin_date.go | 53 ++- date.go | 60 ++-- date_parser.go | 860 ++++++++++++++++++++++++++++++++++++++++++++ date_parser_test.go | 31 ++ date_test.go | 99 +++++ 5 files changed, 1051 insertions(+), 52 deletions(-) create mode 100644 date_parser.go create mode 100644 date_parser_test.go diff --git a/builtin_date.go b/builtin_date.go index fbeaf79d..d5693f35 100644 --- a/builtin_date.go +++ b/builtin_date.go @@ -1,6 +1,7 @@ package goja import ( + "fmt" "math" "time" ) @@ -15,6 +16,10 @@ func timeFromMsec(msec int64) time.Time { return time.Unix(sec, nsec) } +func timeToMsec(t time.Time) int64 { + return t.Unix()*1000 + int64(t.Nanosecond())/1e6 +} + func makeDate(args []Value, loc *time.Location) (t time.Time, valid bool) { pick := func(index int, default_ int64) (int64, bool) { if index >= len(args) { @@ -111,7 +116,11 @@ func (r *Runtime) builtin_date(call FunctionCall) Value { } func (r *Runtime) date_parse(call FunctionCall) Value { - return r.newDateObject(dateParse(call.Argument(0).String())) + t, set := dateParse(call.Argument(0).String()) + if set { + return intToValue(timeToMsec(t)) + } + return _NaN } func (r *Runtime) date_UTC(call FunctionCall) Value { @@ -119,11 +128,11 @@ func (r *Runtime) date_UTC(call FunctionCall) Value { if !valid { return _NaN } - return intToValue(int64(t.UnixNano() / 1e6)) + return intToValue(timeToMsec(t)) } func (r *Runtime) date_now(call FunctionCall) Value { - return intToValue(time.Now().UnixNano() / 1e6) + return intToValue(timeToMsec(time.Now())) } func (r *Runtime) dateproto_toString(call FunctionCall) Value { @@ -156,7 +165,13 @@ func (r *Runtime) dateproto_toISOString(call FunctionCall) Value { obj := r.toObject(call.This) if d, ok := obj.self.(*dateObject); ok { if d.isSet { - return asciiString(d.time.In(time.UTC).Format(isoDateTimeLayout)) + utc := d.time.In(time.UTC) + year := utc.Year() + if year >= -9999 && year <= 9999 { + return asciiString(utc.Format(isoDateTimeLayout)) + } + // extended year + return asciiString(fmt.Sprintf("%+06d-", year) + utc.Format(isoDateTimeLayout[5:])) } else { panic(r.newError(r.global.RangeError, "Invalid time value")) } @@ -270,7 +285,7 @@ func (r *Runtime) dateproto_getTime(call FunctionCall) Value { obj := r.toObject(call.This) if d, ok := obj.self.(*dateObject); ok { if d.isSet { - return intToValue(d.time.UnixNano() / 1e6) + return intToValue(timeToMsec(d.time)) } else { return _NaN } @@ -518,7 +533,7 @@ func (r *Runtime) dateproto_setMilliseconds(call FunctionCall) Value { if d.isSet { msec := int(call.Argument(0).ToInteger()) d.time = time.Date(d.time.Year(), d.time.Month(), d.time.Day(), d.time.Hour(), d.time.Minute(), d.time.Second(), msec*1e6, time.Local) - return intToValue(d.time.UnixNano() / 1e6) + return intToValue(timeToMsec(d.time)) } else { return _NaN } @@ -534,7 +549,7 @@ func (r *Runtime) dateproto_setUTCMilliseconds(call FunctionCall) Value { msec := int(call.Argument(0).ToInteger()) t := d.time.In(time.UTC) d.time = time.Date(t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute(), t.Second(), msec*1e6, time.UTC).In(time.Local) - return intToValue(d.time.UnixNano() / 1e6) + return intToValue(timeToMsec(d.time)) } else { return _NaN } @@ -555,7 +570,7 @@ func (r *Runtime) dateproto_setSeconds(call FunctionCall) Value { nsec = d.time.Nanosecond() } d.time = time.Date(d.time.Year(), d.time.Month(), d.time.Day(), d.time.Hour(), d.time.Minute(), sec, nsec, time.Local) - return intToValue(d.time.UnixNano() / 1e6) + return intToValue(timeToMsec(d.time)) } else { return _NaN } @@ -577,7 +592,7 @@ func (r *Runtime) dateproto_setUTCSeconds(call FunctionCall) Value { nsec = t.Nanosecond() } d.time = time.Date(t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute(), sec, nsec, time.UTC).In(time.Local) - return intToValue(d.time.UnixNano() / 1e6) + return intToValue(timeToMsec(d.time)) } else { return _NaN } @@ -603,7 +618,7 @@ func (r *Runtime) dateproto_setMinutes(call FunctionCall) Value { nsec = d.time.Nanosecond() } d.time = time.Date(d.time.Year(), d.time.Month(), d.time.Day(), d.time.Hour(), min, sec, nsec, time.Local) - return intToValue(d.time.UnixNano() / 1e6) + return intToValue(timeToMsec(d.time)) } else { return _NaN } @@ -630,7 +645,7 @@ func (r *Runtime) dateproto_setUTCMinutes(call FunctionCall) Value { nsec = t.Nanosecond() } d.time = time.Date(t.Year(), t.Month(), t.Day(), t.Hour(), min, sec, nsec, time.UTC).In(time.Local) - return intToValue(d.time.UnixNano() / 1e6) + return intToValue(timeToMsec(d.time)) } else { return _NaN } @@ -661,7 +676,7 @@ func (r *Runtime) dateproto_setHours(call FunctionCall) Value { nsec = d.time.Nanosecond() } d.time = time.Date(d.time.Year(), d.time.Month(), d.time.Day(), hour, min, sec, nsec, time.Local) - return intToValue(d.time.UnixNano() / 1e6) + return intToValue(timeToMsec(d.time)) } else { return _NaN } @@ -693,7 +708,7 @@ func (r *Runtime) dateproto_setUTCHours(call FunctionCall) Value { nsec = t.Nanosecond() } d.time = time.Date(d.time.Year(), d.time.Month(), d.time.Day(), hour, min, sec, nsec, time.UTC).In(time.Local) - return intToValue(d.time.UnixNano() / 1e6) + return intToValue(timeToMsec(d.time)) } else { return _NaN } @@ -707,7 +722,7 @@ func (r *Runtime) dateproto_setDate(call FunctionCall) Value { if d, ok := obj.self.(*dateObject); ok { if d.isSet { d.time = time.Date(d.time.Year(), d.time.Month(), int(call.Argument(0).ToInteger()), d.time.Hour(), d.time.Minute(), d.time.Second(), d.time.Nanosecond(), time.Local) - return intToValue(d.time.UnixNano() / 1e6) + return intToValue(timeToMsec(d.time)) } else { return _NaN } @@ -722,7 +737,7 @@ func (r *Runtime) dateproto_setUTCDate(call FunctionCall) Value { if d.isSet { t := d.time.In(time.UTC) d.time = time.Date(t.Year(), t.Month(), int(call.Argument(0).ToInteger()), t.Hour(), t.Minute(), t.Second(), t.Nanosecond(), time.UTC).In(time.Local) - return intToValue(d.time.UnixNano() / 1e6) + return intToValue(timeToMsec(d.time)) } else { return _NaN } @@ -743,7 +758,7 @@ func (r *Runtime) dateproto_setMonth(call FunctionCall) Value { day = d.time.Day() } d.time = time.Date(d.time.Year(), month, day, d.time.Hour(), d.time.Minute(), d.time.Second(), d.time.Nanosecond(), time.Local) - return intToValue(d.time.UnixNano() / 1e6) + return intToValue(timeToMsec(d.time)) } else { return _NaN } @@ -765,7 +780,7 @@ func (r *Runtime) dateproto_setUTCMonth(call FunctionCall) Value { day = t.Day() } d.time = time.Date(t.Year(), month, day, t.Hour(), t.Minute(), t.Second(), t.Nanosecond(), time.UTC).In(time.Local) - return intToValue(d.time.UnixNano() / 1e6) + return intToValue(timeToMsec(d.time)) } else { return _NaN } @@ -794,7 +809,7 @@ func (r *Runtime) dateproto_setFullYear(call FunctionCall) Value { day = d.time.Day() } d.time = time.Date(year, month, day, d.time.Hour(), d.time.Minute(), d.time.Second(), d.time.Nanosecond(), time.Local) - return intToValue(d.time.UnixNano() / 1e6) + return intToValue(timeToMsec(d.time)) } r.typeErrorResult(true, "Method Date.prototype.setFullYear is called on incompatible receiver") panic("Unreachable") @@ -821,7 +836,7 @@ func (r *Runtime) dateproto_setUTCFullYear(call FunctionCall) Value { day = t.Day() } d.time = time.Date(year, month, day, t.Hour(), t.Minute(), t.Second(), t.Nanosecond(), time.UTC).In(time.Local) - return intToValue(d.time.UnixNano() / 1e6) + return intToValue(timeToMsec(d.time)) } r.typeErrorResult(true, "Method Date.prototype.setUTCFullYear is called on incompatible receiver") panic("Unreachable") diff --git a/date.go b/date.go index cbd2835b..c17d597c 100644 --- a/date.go +++ b/date.go @@ -1,7 +1,6 @@ package goja import ( - "regexp" "time" ) @@ -23,9 +22,22 @@ type dateObject struct { var ( dateLayoutList = []string{ + "2006-01-02T15:04:05.000Z0700", + "2006-01-02T15:04:05.000", + "2006-01-02T15:04:05Z0700", + "2006-01-02T15:04:05", + "2006-01-02", + time.RFC1123, + time.RFC1123Z, + dateTimeLayout, + time.UnixDate, + time.ANSIC, + time.RubyDate, + "Mon, 02 Jan 2006 15:04:05 GMT-0700 (MST)", + "Mon, 02 Jan 2006 15:04:05 -0700 (MST)", + "2006", "2006-01", - "2006-01-02", "2006T15:04", "2006-01T15:04", @@ -33,51 +45,33 @@ var ( "2006T15:04:05", "2006-01T15:04:05", - "2006-01-02T15:04:05", "2006T15:04:05.000", "2006-01T15:04:05.000", - "2006-01-02T15:04:05.000", - - "2006T15:04-0700", - "2006-01T15:04-0700", - "2006-01-02T15:04-0700", - "2006T15:04:05-0700", - "2006-01T15:04:05-0700", - "2006-01-02T15:04:05-0700", + "2006T15:04Z0700", + "2006-01T15:04Z0700", + "2006-01-02T15:04Z0700", - "2006T15:04:05.000-0700", - "2006-01T15:04:05.000-0700", - "2006-01-02T15:04:05.000-0700", + "2006T15:04:05Z0700", + "2006-01T15:04:05Z0700", - time.RFC1123, - dateTimeLayout, + "2006T15:04:05.000Z0700", + "2006-01T15:04:05.000Z0700", } - matchDateTimeZone = regexp.MustCompile(`^(.*)(?:(Z)|([\+\-]\d{2}):(\d{2}))$`) ) func dateParse(date string) (time.Time, bool) { - // YYYY-MM-DDTHH:mm:ss.sssZ var t time.Time var err error - { - date := date - if match := matchDateTimeZone.FindStringSubmatch(date); match != nil { - if match[2] == "Z" { - date = match[1] + "+0000" - } else { - date = match[1] + match[3] + match[4] - } - } - for _, layout := range dateLayoutList { - t, err = time.Parse(layout, date) - if err == nil { - break - } + for _, layout := range dateLayoutList { + t, err = parseDate(layout, date, time.UTC) + if err == nil { + break } } - return t, err == nil + unix := timeToMsec(t) + return t, err == nil && unix >= -8640000000000000 && unix <= 8640000000000000 } func (r *Runtime) newDateObject(t time.Time, isSet bool) *Object { diff --git a/date_parser.go b/date_parser.go new file mode 100644 index 00000000..0841cf40 --- /dev/null +++ b/date_parser.go @@ -0,0 +1,860 @@ +package goja + +// This is a slightly modified version of the standard Go parser to make it more compatible with ECMAScript 5.1 +// Changes: +// - 6-digit extended years are supported in place of long year (2006) in the form of +123456 +// - Timezone formats tolerate colons, e.g. -0700 will parse -07:00 +// - Short week day will also parse long week day +// - Timezone in brackets, "(MST)", will match any string in brackets (e.g. "(GMT Standard Time)") +// - If offset is not set and timezone name is unknown, an error is returned +// - If offset and timezone name are both set the offset takes precedence and the resulting Location will be FixedZone("", offset) + +// Original copyright message: + +// Copyright 2010 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +import ( + "errors" + "time" +) + +const ( + _ = iota + stdLongMonth = iota + stdNeedDate // "January" + stdMonth // "Jan" + stdNumMonth // "1" + stdZeroMonth // "01" + stdLongWeekDay // "Monday" + stdWeekDay // "Mon" + stdDay // "2" + stdUnderDay // "_2" + stdZeroDay // "02" + stdHour = iota + stdNeedClock // "15" + stdHour12 // "3" + stdZeroHour12 // "03" + stdMinute // "4" + stdZeroMinute // "04" + stdSecond // "5" + stdZeroSecond // "05" + stdLongYear = iota + stdNeedDate // "2006" + stdYear // "06" + stdPM = iota + stdNeedClock // "PM" + stdpm // "pm" + stdTZ = iota // "MST" + stdBracketTZ // "(MST)" + stdISO8601TZ // "Z0700" // prints Z for UTC + stdISO8601SecondsTZ // "Z070000" + stdISO8601ShortTZ // "Z07" + stdISO8601ColonTZ // "Z07:00" // prints Z for UTC + stdISO8601ColonSecondsTZ // "Z07:00:00" + stdNumTZ // "-0700" // always numeric + stdNumSecondsTz // "-070000" + stdNumShortTZ // "-07" // always numeric + stdNumColonTZ // "-07:00" // always numeric + stdNumColonSecondsTZ // "-07:00:00" + stdFracSecond0 // ".0", ".00", ... , trailing zeros included + stdFracSecond9 // ".9", ".99", ..., trailing zeros omitted + + stdNeedDate = 1 << 8 // need month, day, year + stdNeedClock = 2 << 8 // need hour, minute, second + stdArgShift = 16 // extra argument in high bits, above low stdArgShift + stdMask = 1<= 69 { // Unix time starts Dec 31 1969 in some time zones + year += 1900 + } else { + year += 2000 + } + case stdLongYear: + if len(value) >= 7 && (value[0] == '-' || value[0] == '+') { // extended year + neg := value[0] == '-' + p, value = value[1:7], value[7:] + year, err = atoi(p) + if neg { + year = -year + } + } else { + if len(value) < 4 || !isDigit(value, 0) { + err = errBad + break + } + p, value = value[0:4], value[4:] + year, err = atoi(p) + } + + case stdMonth: + month, value, err = lookup(shortMonthNames, value) + month++ + case stdLongMonth: + month, value, err = lookup(longMonthNames, value) + month++ + case stdNumMonth, stdZeroMonth: + month, value, err = getnum(value, std == stdZeroMonth) + if month <= 0 || 12 < month { + rangeErrString = "month" + } + case stdWeekDay: + // Ignore weekday except for error checking. + _, value, err = lookup(longDayNames, value) + if err != nil { + _, value, err = lookup(shortDayNames, value) + } + case stdLongWeekDay: + _, value, err = lookup(longDayNames, value) + case stdDay, stdUnderDay, stdZeroDay: + if std == stdUnderDay && len(value) > 0 && value[0] == ' ' { + value = value[1:] + } + day, value, err = getnum(value, std == stdZeroDay) + if day < 0 { + // Note that we allow any one- or two-digit day here. + rangeErrString = "day" + } + case stdHour: + hour, value, err = getnum(value, false) + if hour < 0 || 24 <= hour { + rangeErrString = "hour" + } + case stdHour12, stdZeroHour12: + hour, value, err = getnum(value, std == stdZeroHour12) + if hour < 0 || 12 < hour { + rangeErrString = "hour" + } + case stdMinute, stdZeroMinute: + min, value, err = getnum(value, std == stdZeroMinute) + if min < 0 || 60 <= min { + rangeErrString = "minute" + } + case stdSecond, stdZeroSecond: + sec, value, err = getnum(value, std == stdZeroSecond) + if sec < 0 || 60 <= sec { + rangeErrString = "second" + break + } + // Special case: do we have a fractional second but no + // fractional second in the format? + if len(value) >= 2 && value[0] == '.' && isDigit(value, 1) { + _, std, _ = nextStdChunk(layout) + std &= stdMask + if std == stdFracSecond0 || std == stdFracSecond9 { + // Fractional second in the layout; proceed normally + break + } + // No fractional second in the layout but we have one in the input. + n := 2 + for ; n < len(value) && isDigit(value, n); n++ { + } + nsec, rangeErrString, err = parseNanoseconds(value, n) + value = value[n:] + } + case stdPM: + if len(value) < 2 { + err = errBad + break + } + p, value = value[0:2], value[2:] + switch p { + case "PM": + pmSet = true + case "AM": + amSet = true + default: + err = errBad + } + case stdpm: + if len(value) < 2 { + err = errBad + break + } + p, value = value[0:2], value[2:] + switch p { + case "pm": + pmSet = true + case "am": + amSet = true + default: + err = errBad + } + case stdISO8601TZ, stdISO8601ColonTZ, stdISO8601SecondsTZ, stdISO8601ShortTZ, stdISO8601ColonSecondsTZ, stdNumTZ, stdNumShortTZ, stdNumColonTZ, stdNumSecondsTz, stdNumColonSecondsTZ: + if (std == stdISO8601TZ || std == stdISO8601ShortTZ || std == stdISO8601ColonTZ || + std == stdISO8601SecondsTZ || std == stdISO8601ColonSecondsTZ) && len(value) >= 1 && value[0] == 'Z' { + + value = value[1:] + z = time.UTC + break + } + var sign, hour, min, seconds string + if std == stdISO8601ColonTZ || std == stdNumColonTZ || std == stdNumTZ || std == stdISO8601TZ { + if len(value) < 4 { + err = errBad + break + } + if value[3] != ':' { + if std == stdNumColonTZ || std == stdISO8601ColonTZ || len(value) < 5 { + err = errBad + break + } + sign, hour, min, seconds, value = value[0:1], value[1:3], value[3:5], "00", value[5:] + } else { + if len(value) < 6 { + err = errBad + break + } + sign, hour, min, seconds, value = value[0:1], value[1:3], value[4:6], "00", value[6:] + } + } else if std == stdNumShortTZ || std == stdISO8601ShortTZ { + if len(value) < 3 { + err = errBad + break + } + sign, hour, min, seconds, value = value[0:1], value[1:3], "00", "00", value[3:] + } else if std == stdISO8601ColonSecondsTZ || std == stdNumColonSecondsTZ || std == stdISO8601SecondsTZ || std == stdNumSecondsTz { + if len(value) < 7 { + err = errBad + break + } + if value[3] != ':' || value[6] != ':' { + if std == stdISO8601ColonSecondsTZ || std == stdNumColonSecondsTZ || len(value) < 7 { + err = errBad + break + } + sign, hour, min, seconds, value = value[0:1], value[1:3], value[3:5], value[5:7], value[7:] + } else { + if len(value) < 9 { + err = errBad + break + } + sign, hour, min, seconds, value = value[0:1], value[1:3], value[4:6], value[7:9], value[9:] + } + } + var hr, mm, ss int + hr, err = atoi(hour) + if err == nil { + mm, err = atoi(min) + } + if err == nil { + ss, err = atoi(seconds) + } + zoneOffset = (hr*60+mm)*60 + ss // offset is in seconds + switch sign[0] { + case '+': + case '-': + zoneOffset = -zoneOffset + default: + err = errBad + } + case stdTZ: + // Does it look like a time zone? + if len(value) >= 3 && value[0:3] == "UTC" { + z = time.UTC + value = value[3:] + break + } + n, ok := parseTimeZone(value) + if !ok { + err = errBad + break + } + zoneName, value = value[:n], value[n:] + case stdBracketTZ: + if len(value) < 3 || value[0] != '(' { + err = errBad + break + } + i := 1 + for ; ; i++ { + if i >= len(value) { + err = errBad + break + } + if value[i] == ')' { + zoneName, value = value[1:i], value[i+1:] + break + } + } + + case stdFracSecond0: + // stdFracSecond0 requires the exact number of digits as specified in + // the layout. + ndigit := 1 + (std >> stdArgShift) + if len(value) < ndigit { + err = errBad + break + } + nsec, rangeErrString, err = parseNanoseconds(value, ndigit) + value = value[ndigit:] + + case stdFracSecond9: + if len(value) < 2 || value[0] != '.' || value[1] < '0' || '9' < value[1] { + // Fractional second omitted. + break + } + // Take any number of digits, even more than asked for, + // because it is what the stdSecond case would do. + i := 0 + for i < 9 && i+1 < len(value) && '0' <= value[i+1] && value[i+1] <= '9' { + i++ + } + nsec, rangeErrString, err = parseNanoseconds(value, 1+i) + value = value[1+i:] + } + if rangeErrString != "" { + return time.Time{}, &time.ParseError{Layout: alayout, Value: avalue, LayoutElem: stdstr, ValueElem: value, Message: ": " + rangeErrString + " out of range"} + } + if err != nil { + return time.Time{}, &time.ParseError{Layout: alayout, Value: avalue, LayoutElem: stdstr, ValueElem: value} + } + } + if pmSet && hour < 12 { + hour += 12 + } else if amSet && hour == 12 { + hour = 0 + } + + // Validate the day of the month. + if day < 1 || day > daysIn(time.Month(month), year) { + return time.Time{}, &time.ParseError{Layout: alayout, Value: avalue, ValueElem: value, Message: ": day out of range"} + } + + if z == nil { + if zoneOffset == -1 { + if zoneName != "" { + if z1, err := time.LoadLocation(zoneName); err == nil { + z = z1 + } else { + return time.Time{}, &time.ParseError{Layout: alayout, Value: avalue, ValueElem: value, Message: ": unknown timezone"} + } + } else { + z = defaultLocation + } + } else if zoneOffset == 0 { + z = time.UTC + } else { + z = time.FixedZone("", zoneOffset) + } + } + + return time.Date(year, time.Month(month), day, hour, min, sec, nsec, z), nil +} + +var errLeadingInt = errors.New("time: bad [0-9]*") // never printed + +func signedLeadingInt(s string) (x int64, rem string, err error) { + neg := false + if s != "" && (s[0] == '-' || s[0] == '+') { + neg = s[0] == '-' + s = s[1:] + } + x, rem, err = leadingInt(s) + if err != nil { + return + } + + if neg { + x = -x + } + return +} + +// leadingInt consumes the leading [0-9]* from s. +func leadingInt(s string) (x int64, rem string, err error) { + i := 0 + for ; i < len(s); i++ { + c := s[i] + if c < '0' || c > '9' { + break + } + if x > (1<<63-1)/10 { + // overflow + return 0, "", errLeadingInt + } + x = x*10 + int64(c) - '0' + if x < 0 { + // overflow + return 0, "", errLeadingInt + } + } + return x, s[i:], nil +} + +// nextStdChunk finds the first occurrence of a std string in +// layout and returns the text before, the std string, and the text after. +func nextStdChunk(layout string) (prefix string, std int, suffix string) { + for i := 0; i < len(layout); i++ { + switch c := int(layout[i]); c { + case 'J': // January, Jan + if len(layout) >= i+3 && layout[i:i+3] == "Jan" { + if len(layout) >= i+7 && layout[i:i+7] == "January" { + return layout[0:i], stdLongMonth, layout[i+7:] + } + if !startsWithLowerCase(layout[i+3:]) { + return layout[0:i], stdMonth, layout[i+3:] + } + } + + case 'M': // Monday, Mon, MST + if len(layout) >= i+3 { + if layout[i:i+3] == "Mon" { + if len(layout) >= i+6 && layout[i:i+6] == "Monday" { + return layout[0:i], stdLongWeekDay, layout[i+6:] + } + if !startsWithLowerCase(layout[i+3:]) { + return layout[0:i], stdWeekDay, layout[i+3:] + } + } + if layout[i:i+3] == "MST" { + return layout[0:i], stdTZ, layout[i+3:] + } + } + + case '0': // 01, 02, 03, 04, 05, 06 + if len(layout) >= i+2 && '1' <= layout[i+1] && layout[i+1] <= '6' { + return layout[0:i], std0x[layout[i+1]-'1'], layout[i+2:] + } + + case '1': // 15, 1 + if len(layout) >= i+2 && layout[i+1] == '5' { + return layout[0:i], stdHour, layout[i+2:] + } + return layout[0:i], stdNumMonth, layout[i+1:] + + case '2': // 2006, 2 + if len(layout) >= i+4 && layout[i:i+4] == "2006" { + return layout[0:i], stdLongYear, layout[i+4:] + } + return layout[0:i], stdDay, layout[i+1:] + + case '_': // _2, _2006 + if len(layout) >= i+2 && layout[i+1] == '2' { + //_2006 is really a literal _, followed by stdLongYear + if len(layout) >= i+5 && layout[i+1:i+5] == "2006" { + return layout[0 : i+1], stdLongYear, layout[i+5:] + } + return layout[0:i], stdUnderDay, layout[i+2:] + } + + case '3': + return layout[0:i], stdHour12, layout[i+1:] + + case '4': + return layout[0:i], stdMinute, layout[i+1:] + + case '5': + return layout[0:i], stdSecond, layout[i+1:] + + case 'P': // PM + if len(layout) >= i+2 && layout[i+1] == 'M' { + return layout[0:i], stdPM, layout[i+2:] + } + + case 'p': // pm + if len(layout) >= i+2 && layout[i+1] == 'm' { + return layout[0:i], stdpm, layout[i+2:] + } + + case '-': // -070000, -07:00:00, -0700, -07:00, -07 + if len(layout) >= i+7 && layout[i:i+7] == "-070000" { + return layout[0:i], stdNumSecondsTz, layout[i+7:] + } + if len(layout) >= i+9 && layout[i:i+9] == "-07:00:00" { + return layout[0:i], stdNumColonSecondsTZ, layout[i+9:] + } + if len(layout) >= i+5 && layout[i:i+5] == "-0700" { + return layout[0:i], stdNumTZ, layout[i+5:] + } + if len(layout) >= i+6 && layout[i:i+6] == "-07:00" { + return layout[0:i], stdNumColonTZ, layout[i+6:] + } + if len(layout) >= i+3 && layout[i:i+3] == "-07" { + return layout[0:i], stdNumShortTZ, layout[i+3:] + } + + case 'Z': // Z070000, Z07:00:00, Z0700, Z07:00, + if len(layout) >= i+7 && layout[i:i+7] == "Z070000" { + return layout[0:i], stdISO8601SecondsTZ, layout[i+7:] + } + if len(layout) >= i+9 && layout[i:i+9] == "Z07:00:00" { + return layout[0:i], stdISO8601ColonSecondsTZ, layout[i+9:] + } + if len(layout) >= i+5 && layout[i:i+5] == "Z0700" { + return layout[0:i], stdISO8601TZ, layout[i+5:] + } + if len(layout) >= i+6 && layout[i:i+6] == "Z07:00" { + return layout[0:i], stdISO8601ColonTZ, layout[i+6:] + } + if len(layout) >= i+3 && layout[i:i+3] == "Z07" { + return layout[0:i], stdISO8601ShortTZ, layout[i+3:] + } + + case '.': // .000 or .999 - repeated digits for fractional seconds. + if i+1 < len(layout) && (layout[i+1] == '0' || layout[i+1] == '9') { + ch := layout[i+1] + j := i + 1 + for j < len(layout) && layout[j] == ch { + j++ + } + // String of digits must end here - only fractional second is all digits. + if !isDigit(layout, j) { + std := stdFracSecond0 + if layout[i+1] == '9' { + std = stdFracSecond9 + } + std |= (j - (i + 1)) << stdArgShift + return layout[0:i], std, layout[j:] + } + } + case '(': + if len(layout) >= i+5 && layout[i:i+5] == "(MST)" { + return layout[0:i], stdBracketTZ, layout[i+5:] + } + } + } + return layout, 0, "" +} + +var longDayNames = []string{ + "Sunday", + "Monday", + "Tuesday", + "Wednesday", + "Thursday", + "Friday", + "Saturday", +} + +var shortDayNames = []string{ + "Sun", + "Mon", + "Tue", + "Wed", + "Thu", + "Fri", + "Sat", +} + +var shortMonthNames = []string{ + "Jan", + "Feb", + "Mar", + "Apr", + "May", + "Jun", + "Jul", + "Aug", + "Sep", + "Oct", + "Nov", + "Dec", +} + +var longMonthNames = []string{ + "January", + "February", + "March", + "April", + "May", + "June", + "July", + "August", + "September", + "October", + "November", + "December", +} + +// isDigit reports whether s[i] is in range and is a decimal digit. +func isDigit(s string, i int) bool { + if len(s) <= i { + return false + } + c := s[i] + return '0' <= c && c <= '9' +} + +// getnum parses s[0:1] or s[0:2] (fixed forces the latter) +// as a decimal integer and returns the integer and the +// remainder of the string. +func getnum(s string, fixed bool) (int, string, error) { + if !isDigit(s, 0) { + return 0, s, errBad + } + if !isDigit(s, 1) { + if fixed { + return 0, s, errBad + } + return int(s[0] - '0'), s[1:], nil + } + return int(s[0]-'0')*10 + int(s[1]-'0'), s[2:], nil +} + +func cutspace(s string) string { + for len(s) > 0 && s[0] == ' ' { + s = s[1:] + } + return s +} + +// skip removes the given prefix from value, +// treating runs of space characters as equivalent. +func skip(value, prefix string) (string, error) { + for len(prefix) > 0 { + if prefix[0] == ' ' { + if len(value) > 0 && value[0] != ' ' { + return value, errBad + } + prefix = cutspace(prefix) + value = cutspace(value) + continue + } + if len(value) == 0 || value[0] != prefix[0] { + return value, errBad + } + prefix = prefix[1:] + value = value[1:] + } + return value, nil +} + +// Never printed, just needs to be non-nil for return by atoi. +var atoiError = errors.New("time: invalid number") + +// Duplicates functionality in strconv, but avoids dependency. +func atoi(s string) (x int, err error) { + q, rem, err := signedLeadingInt(s) + x = int(q) + if err != nil || rem != "" { + return 0, atoiError + } + return x, nil +} + +// match reports whether s1 and s2 match ignoring case. +// It is assumed s1 and s2 are the same length. +func match(s1, s2 string) bool { + for i := 0; i < len(s1); i++ { + c1 := s1[i] + c2 := s2[i] + if c1 != c2 { + // Switch to lower-case; 'a'-'A' is known to be a single bit. + c1 |= 'a' - 'A' + c2 |= 'a' - 'A' + if c1 != c2 || c1 < 'a' || c1 > 'z' { + return false + } + } + } + return true +} + +func lookup(tab []string, val string) (int, string, error) { + for i, v := range tab { + if len(val) >= len(v) && match(val[0:len(v)], v) { + return i, val[len(v):], nil + } + } + return -1, val, errBad +} + +// daysBefore[m] counts the number of days in a non-leap year +// before month m begins. There is an entry for m=12, counting +// the number of days before January of next year (365). +var daysBefore = [...]int32{ + 0, + 31, + 31 + 28, + 31 + 28 + 31, + 31 + 28 + 31 + 30, + 31 + 28 + 31 + 30 + 31, + 31 + 28 + 31 + 30 + 31 + 30, + 31 + 28 + 31 + 30 + 31 + 30 + 31, + 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31, + 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30, + 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31, + 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30, + 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30 + 31, +} + +func isLeap(year int) bool { + return year%4 == 0 && (year%100 != 0 || year%400 == 0) +} + +func daysIn(m time.Month, year int) int { + if m == time.February && isLeap(year) { + return 29 + } + return int(daysBefore[m] - daysBefore[m-1]) +} + +// parseTimeZone parses a time zone string and returns its length. Time zones +// are human-generated and unpredictable. We can't do precise error checking. +// On the other hand, for a correct parse there must be a time zone at the +// beginning of the string, so it's almost always true that there's one +// there. We look at the beginning of the string for a run of upper-case letters. +// If there are more than 5, it's an error. +// If there are 4 or 5 and the last is a T, it's a time zone. +// If there are 3, it's a time zone. +// Otherwise, other than special cases, it's not a time zone. +// GMT is special because it can have an hour offset. +func parseTimeZone(value string) (length int, ok bool) { + if len(value) < 3 { + return 0, false + } + // Special case 1: ChST and MeST are the only zones with a lower-case letter. + if len(value) >= 4 && (value[:4] == "ChST" || value[:4] == "MeST") { + return 4, true + } + // Special case 2: GMT may have an hour offset; treat it specially. + if value[:3] == "GMT" { + length = parseGMT(value) + return length, true + } + // Special Case 3: Some time zones are not named, but have +/-00 format + if value[0] == '+' || value[0] == '-' { + length = parseSignedOffset(value) + return length, true + } + // How many upper-case letters are there? Need at least three, at most five. + var nUpper int + for nUpper = 0; nUpper < 6; nUpper++ { + if nUpper >= len(value) { + break + } + if c := value[nUpper]; c < 'A' || 'Z' < c { + break + } + } + switch nUpper { + case 0, 1, 2, 6: + return 0, false + case 5: // Must end in T to match. + if value[4] == 'T' { + return 5, true + } + case 4: + // Must end in T, except one special case. + if value[3] == 'T' || value[:4] == "WITA" { + return 4, true + } + case 3: + return 3, true + } + return 0, false +} + +// parseGMT parses a GMT time zone. The input string is known to start "GMT". +// The function checks whether that is followed by a sign and a number in the +// range -14 through 12 excluding zero. +func parseGMT(value string) int { + value = value[3:] + if len(value) == 0 { + return 3 + } + + return 3 + parseSignedOffset(value) +} + +// parseSignedOffset parses a signed timezone offset (e.g. "+03" or "-04"). +// The function checks for a signed number in the range -14 through +12 excluding zero. +// Returns length of the found offset string or 0 otherwise +func parseSignedOffset(value string) int { + sign := value[0] + if sign != '-' && sign != '+' { + return 0 + } + x, rem, err := leadingInt(value[1:]) + if err != nil { + return 0 + } + if sign == '-' { + x = -x + } + if x == 0 || x < -14 || 12 < x { + return 0 + } + return len(value) - len(rem) +} + +func parseNanoseconds(value string, nbytes int) (ns int, rangeErrString string, err error) { + if value[0] != '.' { + err = errBad + return + } + if ns, err = atoi(value[1:nbytes]); err != nil { + return + } + if ns < 0 || 1e9 <= ns { + rangeErrString = "fractional second" + return + } + // We need nanoseconds, which means scaling by the number + // of missing digits in the format, maximum length 10. If it's + // longer than 10, we won't scale. + scaleDigits := 10 - nbytes + for i := 0; i < scaleDigits; i++ { + ns *= 10 + } + return +} + +// std0x records the std values for "01", "02", ..., "06". +var std0x = [...]int{stdZeroMonth, stdZeroDay, stdZeroHour12, stdZeroMinute, stdZeroSecond, stdYear} + +// startsWithLowerCase reports whether the string has a lower-case letter at the beginning. +// Its purpose is to prevent matching strings like "Month" when looking for "Mon". +func startsWithLowerCase(str string) bool { + if len(str) == 0 { + return false + } + c := str[0] + return 'a' <= c && c <= 'z' +} diff --git a/date_parser_test.go b/date_parser_test.go new file mode 100644 index 00000000..c9a5446b --- /dev/null +++ b/date_parser_test.go @@ -0,0 +1,31 @@ +package goja + +import ( + "testing" + "time" +) + +func TestParseDate(t *testing.T) { + + tst := func(layout, value string, expectedTs int64) func(t *testing.T) { + return func(t *testing.T) { + t.Parallel() + tm, err := parseDate(layout, value, time.UTC) + if err != nil { + t.Fatal(err) + } + if tm.Unix() != expectedTs { + t.Fatal(tm) + } + } + } + + t.Run("1", tst("2006-01-02T15:04:05.000Z070000", "2006-01-02T15:04:05.000+07:00:00", 1136189045)) + t.Run("2", tst("2006-01-02T15:04:05.000Z07:00:00", "2006-01-02T15:04:05.000+07:00:00", 1136189045)) + t.Run("3", tst("2006-01-02T15:04:05.000Z07:00", "2006-01-02T15:04:05.000+07:00", 1136189045)) + t.Run("4", tst("2006-01-02T15:04:05.000Z070000", "2006-01-02T15:04:05.000+070000", 1136189045)) + t.Run("5", tst("2006-01-02T15:04:05.000Z070000", "2006-01-02T15:04:05.000Z", 1136214245)) + t.Run("6", tst("2006-01-02T15:04:05.000Z0700", "2006-01-02T15:04:05.000Z", 1136214245)) + t.Run("7", tst("2006-01-02T15:04:05.000Z07", "2006-01-02T15:04:05.000Z", 1136214245)) + +} diff --git a/date_test.go b/date_test.go index c097ceb7..3f8aefc5 100644 --- a/date_test.go +++ b/date_test.go @@ -217,3 +217,102 @@ func TestDateSetters(t *testing.T) { testScript1(TESTLIB+SCRIPT, _undefined, t) } + +func TestDateParse(t *testing.T) { + const SCRIPT = ` +var zero = new Date(0); + +assert.sameValue(zero.valueOf(), Date.parse(zero.toString()), + "Date.parse(zeroDate.toString())"); +assert.sameValue(zero.valueOf(), Date.parse(zero.toUTCString()), + "Date.parse(zeroDate.toUTCString())"); +assert.sameValue(zero.valueOf(), Date.parse(zero.toISOString()), + "Date.parse(zeroDate.toISOString())"); + +assert.sameValue(Date.parse("Mon, 02 Jan 2006 15:04:05 MST"), 1136239445000, + "Date.parse(\"Mon, 02 Jan 2006 15:04:05 MST\")"); + +assert.sameValue(Date.parse("Mon, 02 Jan 2006 15:04:05 GMT-07:00 (MST)"), 1136239445000, + "Date.parse(\"Mon, 02 Jan 2006 15:04:05 GMT-07:00 (MST)\")"); + +assert.sameValue(Date.parse("Mon, 02 Jan 2006 15:04:05 -07:00 (MST)"), 1136239445000, + "Date.parse(\"Mon, 02 Jan 2006 15:04:05 -07:00 (MST)\")"); + +assert.sameValue(Date.parse("Monday, 02 Jan 2006 15:04:05 -0700 (MST)"), 1136239445000, + "Date.parse(\"Monday, 02 Jan 2006 15:04:05 -0700 (MST)\")"); + +assert.sameValue(Date.parse("Mon Jan 02 2006 15:04:05 GMT-0700 (GMT Standard Time)"), 1136239445000, + "Date.parse(\"Mon Jan 02 2006 15:04:05 GMT-0700 (GMT Standard Time)\")"); + +assert.sameValue(Date.parse("2006-01-02T15:04:05.000Z"), 1136214245000, + "Date.parse(\"2006-01-02T15:04:05.000Z\")"); + +assert.sameValue(Date.parse("2006-06-02T15:04:05.000"), 1149260645000, + "Date.parse(\"2006-01-02T15:04:05.000\")"); + +assert.sameValue(Date.parse("2006-01-02T15:04:05"), 1136214245000, + "Date.parse(\"2006-01-02T15:04:05\")"); + +assert.sameValue(Date.parse("2006-01-02"), 1136160000000, + "Date.parse(\"2006-01-02\")"); + +assert.sameValue(Date.parse("2006T15:04-0700"), 1136153040000, + "Date.parse(\"2006T15:04-0700\")"); + +assert.sameValue(Date.parse("2006T15:04Z"), 1136127840000, + "Date.parse(\"2006T15:04Z\")"); + +assert.sameValue(Date.parse("Mon Jan 2 15:04:05 MST 2006"), 1136239445000, + "Date.parse(\"Mon Jan 2 15:04:05 MST 2006\")"); + +assert.sameValue(Date.parse("Mon Jan 02 15:04:05 MST 2006"), 1136239445000, + "Date.parse(\"Mon Jan 02 15:04:05 MST 2006\")"); + +assert.sameValue(Date.parse("Mon Jan 02 15:04:05 -0700 2006"), 1136239445000, + "Date.parse(\"Mon Jan 02 15:04:05 -0700 2006\")"); + +var d = new Date("Mon, 02 Jan 2006 15:04:05 MST"); + +assert.sameValue(d.getUTCHours(), 22, + "new Date(\"Mon, 02 Jan 2006 15:04:05 MST\").getUTCHours()"); + +assert.sameValue(d.getHours(), 17, + "new Date(\"Mon, 02 Jan 2006 15:04:05 MST\").getHours()"); + +assert.sameValue(Date.parse("Mon, 02 Jan 2006 15:04:05 zzz"), NaN, + "Date.parse(\"Mon, 02 Jan 2006 15:04:05 zzz\")"); + +assert.sameValue(Date.parse("Mon, 02 Jan 2006 15:04:05 ZZZ"), NaN, + "Date.parse(\"Mon, 02 Jan 2006 15:04:05 ZZZ\")"); + +var minDateStr = "-271821-04-20T00:00:00.000Z"; +var minDate = new Date(-8640000000000000); + +assert.sameValue(minDate.toISOString(), minDateStr, "minDateStr"); +assert.sameValue(Date.parse(minDateStr), minDate.valueOf(), "parse minDateStr"); + +var maxDateStr = "+275760-09-13T00:00:00.000Z"; +var maxDate = new Date(8640000000000000); + +assert.sameValue(maxDate.toISOString(), maxDateStr, "maxDateStr"); +assert.sameValue(Date.parse(maxDateStr), maxDate.valueOf(), "parse maxDateStr"); + +var belowRange = "-271821-04-19T23:59:59.999Z"; +var aboveRange = "+275760-09-13T00:00:00.001Z"; + +assert.sameValue(Date.parse(belowRange), NaN, "parse below minimum time value"); +assert.sameValue(Date.parse(aboveRange), NaN, "parse above maximum time value"); + ` + + l := time.Local + defer func() { + time.Local = l + }() + var err error + time.Local, err = time.LoadLocation("America/New_York") + if err != nil { + t.Fatal(err) + } + + testScript1(TESTLIB+SCRIPT, _undefined, t) +}