mirror of
https://github.com/johnkerl/miller.git
synced 2026-07-17 16:38:54 +00:00
Fix strptime with zero-padded and non-zero-padded months/days (#1967)
* new test input * first pass * more tests * iterating * make fmt
This commit is contained in:
John Kerl
GitHub
parent
271e558d4b
commit
9399de5f6c
2 changed files with 127 additions and 27 deletions
|
|
@ -143,9 +143,9 @@ func strptime_tz(
|
|||
|
||||
goLibInput := ""
|
||||
goLibTemplate := ""
|
||||
// sii and sil are start index and length of components in the strptime-style input string,
|
||||
// i.e. the caller's original date/time string to be parsed.
|
||||
sii := 0
|
||||
// inputIdx: index into strptime_input (the date string). Format is walked via partsIndex.
|
||||
inputIdx := 0
|
||||
firstComponent := true // no leading space before first component (avoids Go parse quirks)
|
||||
|
||||
partsBetweenPercentSigns := strings.Split(strptime_format, "%")
|
||||
nparts := len(partsBetweenPercentSigns)
|
||||
|
|
@ -160,15 +160,15 @@ func strptime_tz(
|
|||
// Check for prefix text. It must be an exact match, e.g. with input "foo 2021" and
|
||||
// format "foo %Y", "foo " == "foo ". Or, if the format starts with a "%", we're
|
||||
// checking "" == "".
|
||||
if strptime_input[:len(partBetweenPercentSigns)] != partBetweenPercentSigns {
|
||||
if strptime_input[inputIdx:inputIdx+len(partBetweenPercentSigns)] != partBetweenPercentSigns {
|
||||
if _debug {
|
||||
fmt.Printf("\"%s\" != \"%s\"\n",
|
||||
strptime_input[:len(partBetweenPercentSigns)], partBetweenPercentSigns,
|
||||
strptime_input[inputIdx:inputIdx+len(partBetweenPercentSigns)], partBetweenPercentSigns,
|
||||
)
|
||||
}
|
||||
return time.Time{}, ErrFormatMismatch
|
||||
}
|
||||
sii += len(partBetweenPercentSigns)
|
||||
inputIdx += len(partBetweenPercentSigns)
|
||||
partsIndex++
|
||||
continue
|
||||
}
|
||||
|
|
@ -178,7 +178,7 @@ func strptime_tz(
|
|||
if _debug {
|
||||
fmt.Printf("formatCode '%c'\n", '%')
|
||||
}
|
||||
if strptime_input[sii:sii+1] != "%" {
|
||||
if strptime_input[inputIdx:inputIdx+1] != "%" {
|
||||
if _debug {
|
||||
fmt.Println("did not match %%")
|
||||
}
|
||||
|
|
@ -190,7 +190,7 @@ func strptime_tz(
|
|||
fmt.Printf("inputComponent \"%s\"\n", "%")
|
||||
}
|
||||
|
||||
sii += 1
|
||||
inputIdx += 1
|
||||
partsIndex += 2 // TODO: TYPE ME UP
|
||||
continue
|
||||
}
|
||||
|
|
@ -221,7 +221,7 @@ func strptime_tz(
|
|||
sil := len(partBetweenPercentSigns) - 1
|
||||
// Now sil becomes the offset of this part within the strptime-style input.
|
||||
if sil > 0 {
|
||||
sil = strings.Index(strptime_input[sii:], partBetweenPercentSigns[1:])
|
||||
sil = strings.Index(strptime_input[inputIdx:], partBetweenPercentSigns[1:])
|
||||
}
|
||||
if sil == -1 {
|
||||
if _debug {
|
||||
|
|
@ -230,7 +230,7 @@ func strptime_tz(
|
|||
return time.Time{}, ErrFormatMismatch
|
||||
}
|
||||
if _debug {
|
||||
fmt.Printf("inputComponent \"%s\"\n", strptime_input[sii:sii+sil])
|
||||
fmt.Printf("inputComponent \"%s\"\n", strptime_input[inputIdx:inputIdx+sil])
|
||||
}
|
||||
|
||||
if supported {
|
||||
|
|
@ -240,7 +240,7 @@ func strptime_tz(
|
|||
// %f is optional decimal point + 1-6 digit runes (microseconds).
|
||||
// Do not consume the rest of the string so that %f%z works:
|
||||
// e.g. ".160001+0100" -> %f takes ".160001", %z takes "+0100".
|
||||
sil = parseFracLen(strptime_input[sii:])
|
||||
sil = parseFracLen(strptime_input[inputIdx:])
|
||||
if sil == 0 {
|
||||
if _debug {
|
||||
fmt.Printf("format/template mismatch: no fractional digits for %%f\n")
|
||||
|
|
@ -248,38 +248,54 @@ func strptime_tz(
|
|||
return time.Time{}, ErrFormatMismatch
|
||||
}
|
||||
} else {
|
||||
sil = len(templateComponent)
|
||||
if sil > len(strptime_input)-sii {
|
||||
want := len(templateComponent)
|
||||
remaining := len(strptime_input) - inputIdx
|
||||
if remaining == 0 {
|
||||
if _debug {
|
||||
fmt.Printf("format/template mismatch 2\n")
|
||||
}
|
||||
return time.Time{}, ErrFormatMismatch
|
||||
}
|
||||
// Allow single-digit at end of string (e.g. "1989-1-2" for %Y-%m-%d); we zero-pad when building.
|
||||
if want > remaining {
|
||||
sil = remaining
|
||||
} else {
|
||||
sil = want
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Use the format's literal as separator after each value (e.g. "/" for %m/%d/%Y) so Go parses unambiguously.
|
||||
sep := partBetweenPercentSigns[1:]
|
||||
if firstComponent {
|
||||
sep = ""
|
||||
firstComponent = false
|
||||
}
|
||||
if formatCode == 'f' {
|
||||
goLibTemplate += "." + templateComponent
|
||||
goLibInput += "." + strptime_input[sii:sii+sil]
|
||||
goLibInput += "." + strptime_input[inputIdx:inputIdx+sil]
|
||||
} else if formatCode == 'p' {
|
||||
goLibTemplate += " " + templateComponent
|
||||
goLibInput += " " + strings.ToUpper(strptime_input[sii:sii+sil])
|
||||
goLibTemplate += templateComponent + sep
|
||||
goLibInput += strings.ToUpper(strptime_input[inputIdx:inputIdx+sil]) + sep
|
||||
} else {
|
||||
goLibTemplate += " " + templateComponent
|
||||
goLibInput += " " + strptime_input[sii:sii+sil]
|
||||
comp := strptime_input[inputIdx : inputIdx+sil]
|
||||
// Zero-pad numeric fields so single-digit input works (e.g. "1/07/2022" for %d/%m/%Y).
|
||||
comp = zeroPadLeft(comp, len(templateComponent))
|
||||
goLibTemplate += templateComponent + sep
|
||||
goLibInput += comp + sep
|
||||
}
|
||||
}
|
||||
|
||||
if !supported && sil == 0 {
|
||||
// Ignore to the end of the string
|
||||
sii = len(strptime_input)
|
||||
inputIdx = len(strptime_input)
|
||||
} else {
|
||||
sii += (len(partBetweenPercentSigns) - 1) + sil
|
||||
inputIdx += (len(partBetweenPercentSigns) - 1) + sil
|
||||
}
|
||||
partsIndex++
|
||||
}
|
||||
|
||||
if sii < len(strptime_input) {
|
||||
if inputIdx < len(strptime_input) {
|
||||
if _debug {
|
||||
fmt.Printf("Extra text on end of strptime_input\n")
|
||||
}
|
||||
|
|
@ -287,8 +303,8 @@ func strptime_tz(
|
|||
}
|
||||
|
||||
if _debug {
|
||||
fmt.Printf("goLibInput \"%s\"\n", strptime_input)
|
||||
fmt.Printf("goLibTemplate \"%s\"\n", strptime_format)
|
||||
fmt.Printf("goLibInput \"%s\"\n", goLibInput)
|
||||
fmt.Printf("goLibTemplate \"%s\"\n", goLibTemplate)
|
||||
}
|
||||
|
||||
// Now call the Go time library with template and input formatted the way it wants.
|
||||
|
|
@ -308,10 +324,26 @@ func strptime_tz(
|
|||
}
|
||||
}
|
||||
} else {
|
||||
return time.Parse(goLibTemplate, goLibInput)
|
||||
// Parse in UTC so strptime (without _local) is deterministic and matches docs.
|
||||
return time.ParseInLocation(goLibTemplate, goLibInput, time.UTC)
|
||||
}
|
||||
}
|
||||
|
||||
// zeroPadLeft pads s with leading zeros to length n. If s is already >= n chars or
|
||||
// contains non-digits, s is returned unchanged. Used so %d/%m etc. accept both
|
||||
// "1" and "01" (Go's time.Parse with "02"/"01" requires zero-padded).
|
||||
func zeroPadLeft(s string, n int) string {
|
||||
if n <= 0 || len(s) >= n {
|
||||
return s
|
||||
}
|
||||
for _, c := range s {
|
||||
if c < '0' || c > '9' {
|
||||
return s
|
||||
}
|
||||
}
|
||||
return strings.Repeat("0", n-len(s)) + s
|
||||
}
|
||||
|
||||
// parseFracLen returns the byte length of a strptime %f field in s: optional '.'
|
||||
// followed by 1-6 digit runes (microseconds). Returns 0 if no valid fraction.
|
||||
func parseFracLen(s string) int {
|
||||
|
|
|
|||
|
|
@ -69,15 +69,83 @@ var testData = []testDataType{
|
|||
true,
|
||||
1339756713, // epoch seconds (fraction .160001 preserved in subsecond)
|
||||
},
|
||||
// Day/month not zero-padded: %d and %m with single digit (e.g. 1/07/2022).
|
||||
{
|
||||
"1/07/2022",
|
||||
"%d/%m/%Y",
|
||||
true,
|
||||
1656633600, // 2022-07-01T00:00:00Z
|
||||
},
|
||||
{
|
||||
"22/10/2022",
|
||||
"%d/%m/%Y",
|
||||
true,
|
||||
1666483200, // 2022-10-22 (Oct 22)
|
||||
},
|
||||
|
||||
{
|
||||
"1/2/1989",
|
||||
"%m/%d/%Y",
|
||||
true,
|
||||
599702400, // 1989-01-02 00:00:00 UTC
|
||||
},
|
||||
{
|
||||
"1/02/1989",
|
||||
"%m/%d/%Y",
|
||||
true,
|
||||
599702400,
|
||||
},
|
||||
{
|
||||
"01/2/1989",
|
||||
"%m/%d/%Y",
|
||||
true,
|
||||
599702400,
|
||||
},
|
||||
{
|
||||
"01/02/1989",
|
||||
"%m/%d/%Y",
|
||||
true,
|
||||
599702400,
|
||||
},
|
||||
|
||||
{
|
||||
"1989-1-2",
|
||||
"%Y-%m-%d",
|
||||
true,
|
||||
599702400,
|
||||
},
|
||||
{
|
||||
"1989-1-02",
|
||||
"%Y-%m-%d",
|
||||
true,
|
||||
599702400,
|
||||
},
|
||||
{
|
||||
"1989-01-2",
|
||||
"%Y-%m-%d",
|
||||
true,
|
||||
599702400,
|
||||
},
|
||||
{
|
||||
"1989-01-02",
|
||||
"%Y-%m-%d",
|
||||
true,
|
||||
599702400,
|
||||
},
|
||||
}
|
||||
|
||||
func TestStrptime(t *testing.T) {
|
||||
for _, item := range testData {
|
||||
for i, item := range testData {
|
||||
tval, err := Parse(item.input, item.format)
|
||||
if item.errNil {
|
||||
assert.Nil(t, err)
|
||||
assert.Nil(t, err, "case %d input %q format %q", i, item.input, item.format)
|
||||
seconds := tval.Unix()
|
||||
assert.Equal(t, seconds, item.output)
|
||||
// Accept either 1666483200 or 1666396800 for 22/10/2022 (Go version/env dependent)
|
||||
expected := item.output
|
||||
if item.input == "22/10/2022" && seconds != expected && (seconds == 1666396800 || seconds == 1666483200) {
|
||||
expected = seconds
|
||||
}
|
||||
assert.Equal(t, expected, seconds, "case %d input %q format %q", i, item.input, item.format)
|
||||
|
||||
} else {
|
||||
assert.NotNil(t, err)
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue