Make absolute parser can detect if parsed time period is hour, minute, or second

Author: RadhiFadlillah

internal/parser/absolute/parser.go

@@ -278,8 +278,9 @@ func (p *Parser) Parse(tz timezone.OffsetData) (date.Date, error) {
 	}
 
 	// Parse time
+	var parsedTimePeriod date.Period
 	if timeToken, exist := p.ComponentTokens["time"]; exist {
-		p.ParsedTime, err = common.ParseTime(timeToken.Text)
+		p.ParsedTime, parsedTimePeriod, err = common.ParseTime(timeToken.Text)
 		if err != nil {
 			return date.Date{}, err
 		}
@@ -311,9 +312,17 @@ func (p *Parser) Parse(tz timezone.OffsetData) (date.Date, error) {
 	// Apply correction for preference of day: beginning, current, end
 	dt = p.correctForDay(dt)
 
+	// Get the period of this date
+	returnTimeAsPeriod := p.Config != nil && p.Config.ReturnTimeAsPeriod
+
+	datePeriod := p.getPeriod()
+	if !p.ParsedTime.IsZero() && returnTimeAsPeriod {
+		datePeriod = min(datePeriod, parsedTimePeriod)
+	}
+
 	return date.Date{
 		Time:   dt,
-		Period: p.getPeriod(),
+		Period: datePeriod,
 	}, nil
 }
 
@@ -571,16 +580,12 @@ func (p *Parser) correctForMonth(t time.Time) time.Time {
 }
 
 func (p *Parser) getPeriod() date.Period {
-	timeExist := !p.ParsedTime.IsZero()
 	_, dayExist := p.ComponentValues["day"]
 	_, monthExist := p.ComponentValues["month"]
 	_, yearExist := p.ComponentValues["year"]
-	returnTimeAsPeriod := p.Config != nil && p.Config.ReturnTimeAsPeriod
 
 	switch {
-	case returnTimeAsPeriod && timeExist:
-		return date.Hour
-	case timeExist || dayExist:
+	case dayExist:
 		return date.Day
 	case monthExist:
 		return date.Month

internal/parser/common/time.go

@@ -4,32 +4,37 @@ import (
 	"fmt"
 	"strings"
 	"time"
+
+	"github.com/markusmobius/go-dateparser/date"
 )
 
 // ParseTime parses the specified string using one of the common time formats.
-func ParseTime(s string) (time.Time, error) {
-	timeFormats := []string{
-		"15:4:5",
-		"3:4:5 PM",
-		"15:4",
-		"3:4 PM",
-		"3 PM",
-		"15:4:5.999999",
-		"3:4:5.999999 PM",
-		"15:4 PM",
+func ParseTime(s string) (time.Time, date.Period, error) {
+	timeFormats := []struct {
+		Pattern string
+		Period  date.Period
+	}{
+		{"15:4:5", date.Second},
+		{"3:4:5 PM", date.Second},
+		{"15:4", date.Minute},
+		{"3:4 PM", date.Minute},
+		{"3 PM", date.Hour},
+		{"15:4:5.999999", date.Second},
+		{"3:4:5.999999 PM", date.Second},
+		{"15:4 PM", date.Minute},
 	}
 
 	tmp := strings.TrimSpace(s)
 	tmp = strings.ToUpper(tmp)
 	for _, format := range timeFormats {
-		t, err := time.Parse(format, tmp)
+		t, err := time.Parse(format.Pattern, tmp)
 		if err != nil {
 			continue
 		}
 
-		return t, nil
+		return t, format.Period, nil
 	}
 
 	err := fmt.Errorf("%s doesn't seem to be a valid time", s)
-	return time.Time{}, err
+	return time.Time{}, date.None, err
 }

internal/parser/common/time_test.go

@@ -4,35 +4,40 @@ import (
 	"testing"
 	"time"
 
+	"github.com/markusmobius/go-dateparser/date"
 	"github.com/stretchr/testify/assert"
 )
 
 func TestParseTime(t *testing.T) {
 	// Helper function
-	isEqual := func(s string, hour, min, sec, msec int) {
-		expected := time.Date(0, 1, 1, hour, min, sec, msec*1_000, time.UTC)
-		result, _ := ParseTime(s)
-		assert.Equal(t, expected, result, s)
+	isEqual := func(s string, hour, min, sec, msec int, expectedPeriod date.Period) {
+		expectedTime := time.Date(0, 1, 1, hour, min, sec, msec*1_000, time.UTC)
+		result, period, _ := ParseTime(s)
+		assert.Equal(t, expectedTime, result, s)
+		assert.Equal(t, expectedPeriod, period, s)
 	}
 
 	isZero := func(s string) {
-		result, _ := ParseTime(s)
+		result, period, _ := ParseTime(s)
 		assert.True(t, result.IsZero(), s)
+		assert.Equal(t, date.None, period)
 	}
 
 	// Time should be parsed
-	isEqual("11:30:14", 11, 30, 14, 0)
-	isEqual("11:30", 11, 30, 0, 0)
-	isEqual("11:30 PM", 23, 30, 0, 0)
-	isEqual("13:30 PM", 13, 30, 0, 0)
-	isEqual("16:14 AM", 16, 14, 0, 0)
-	isEqual("23:30 AM", 23, 30, 0, 0)
-	isEqual("1:30 AM", 1, 30, 0, 0)
-	isEqual("1:30:15.330 AM", 1, 30, 15, 330000)
-	isEqual("1:30:15.330 PM", 13, 30, 15, 330000)
-	isEqual("1:30:15.3301 PM", 13, 30, 15, 330100)
-	isEqual("11:20:05 AM", 11, 20, 5, 0)
-	isEqual("14:30:15.330100", 14, 30, 15, 330100)
+	isEqual("11:30:14", 11, 30, 14, 0, date.Second)
+	isEqual("11:30", 11, 30, 0, 0, date.Minute)
+	isEqual("11:30 PM", 23, 30, 0, 0, date.Minute)
+	isEqual("13:30 PM", 13, 30, 0, 0, date.Minute)
+	isEqual("16:14 AM", 16, 14, 0, 0, date.Minute)
+	isEqual("23:30 AM", 23, 30, 0, 0, date.Minute)
+	isEqual("1:30 AM", 1, 30, 0, 0, date.Minute)
+	isEqual("1:30:15.330 AM", 1, 30, 15, 330000, date.Second)
+	isEqual("1:30:15.330 PM", 13, 30, 15, 330000, date.Second)
+	isEqual("1:30:15.3301 PM", 13, 30, 15, 330100, date.Second)
+	isEqual("11:20:05 AM", 11, 20, 5, 0, date.Second)
+	isEqual("14:30:15.330100", 14, 30, 15, 330100, date.Second)
+	isEqual("11 AM", 11, 0, 0, 0, date.Hour)
+	isEqual("11 PM", 23, 0, 0, 0, date.Hour)
 
 	// Time is invalid
 	isZero("11")

internal/parser/relative/parser.go

@@ -31,7 +31,7 @@ func Parse(cfg *setting.Configuration, str string) date.Date {
 	str, tzData := timezone.PopTzOffset(str)
 
 	// Parse time
-	t, _ := parseTime(str)
+	t, tPeriod, _ := parseTime(str)
 
 	// Find current time
 	now := time.Now().UTC()
@@ -54,9 +54,7 @@ func Parse(cfg *setting.Configuration, str string) date.Date {
 		dt = time.Date(dt.Year(), dt.Month(), dt.Day(),
 			t.Hour(), t.Minute(), t.Second(), t.Nanosecond(),
 			dt.Location())
-		if period > date.Hour {
-			period = date.Hour
-		}
+		period = min(period, tPeriod)
 	}
 
 	if cfg != nil && !cfg.ReturnTimeAsPeriod && period.IsTime() {
@@ -67,7 +65,7 @@ func Parse(cfg *setting.Configuration, str string) date.Date {
 	return date.Date{Time: dt, Period: period}
 }
 
-func parseTime(s string) (time.Time, error) {
+func parseTime(s string) (time.Time, date.Period, error) {
 	s = rxRelativePattern.ReplaceAllString(s, "")
 	s = rxInAgo.ReplaceAllString(s, "")
 	return common.ParseTime(s)

internal/parser/timestamp/parser.go

@@ -18,7 +18,7 @@ var (
 func Parse(cfg *setting.Configuration, str string, negative bool) date.Date {
 	period := date.Day
 	if cfg != nil && cfg.ReturnTimeAsPeriod {
-		period = date.Hour
+		period = date.Second
 	}
 
 	var rx *regexp.Regexp

parser-relative_test.go

@@ -66,7 +66,7 @@ func TestParser_Parse_relative_pastAndFutureDates(t *testing.T) {
 
 		// English dates
 		{"yesterday", pfpDiff{"day": -1}, Day},
-		{"yesterday at 11:30", pfpDiff{"hour": -23}, Hour},
+		{"yesterday at 11:30", pfpDiff{"hour": -23}, Minute},
 		{"1 decade", pfpDiff{"year": -10}, Year},
 		{"1 decade 2 years", pfpDiff{"year": -12}, Year},
 		{"1 decade 12 months", pfpDiff{"year": -10, "month": -12}, Month},

parser_test.go

@@ -521,40 +521,34 @@ func TestParser_Parse_returnTimeAsPeriod(t *testing.T) {
 		ExpectedPeriod date.Period
 	}
 
-	ts := func(text string, eTime time.Time, bTime ...time.Time) testScenario {
+	ts := func(text string, ePeriod date.Period, eTime time.Time, bTime ...time.Time) testScenario {
 		var baseTime time.Time
 		if len(bTime) > 0 {
 			baseTime = bTime[0]
 		}
-		return testScenario{text, baseTime, eTime, date.Hour}
-	}
-
-	tsd := func(text string, eTime time.Time, bTime ...time.Time) testScenario {
-		test := ts(text, eTime, bTime...)
-		test.ExpectedPeriod = date.Day
-		return test
+		return testScenario{text, baseTime, eTime, ePeriod}
 	}
 
 	tests := []testScenario{
 		// Timestamp
-		ts("1484823450", tt(2017, 1, 19, 10, 57, 30)),
-		ts("1436745600000", tt(2015, 7, 13, 0, 0)),
-		ts("1015673450", tt(2002, 3, 9, 11, 30, 50)),
-		ts("2016-09-23T02:54:32.845Z", tt(2016, 9, 23, 2, 54, 32, 845000)),
+		ts("1484823450", date.Second, tt(2017, 1, 19, 10, 57, 30)),
+		ts("1436745600000", date.Second, tt(2015, 7, 13, 0, 0)),
+		ts("1015673450", date.Second, tt(2002, 3, 9, 11, 30, 50)),
+		ts("2016-09-23T02:54:32.845Z", date.Second, tt(2016, 9, 23, 2, 54, 32, 845000)),
 
 		// Basic text
-		ts("12th December 2019 19:00", tt(2019, 12, 12, 19, 0)),
-		ts("9 Jan 11 0:00", tt(2011, 1, 9, 0, 0)),
+		ts("12th December 2019 19:00", date.Minute, tt(2019, 12, 12, 19, 0)),
+		ts("9 Jan 11 0:00", date.Minute, tt(2011, 1, 9, 0, 0)),
 
 		// Basic text with base time
-		ts("10:04am EDT", tt(2020, 7, 19, 14, 4), tt(2020, 7, 19)),
-		ts("16:00", tt(2018, 12, 13, 16, 0), tt(2018, 12, 13, 15, 15)),
-		ts("Monday 7:15 AM", tt(2018, 12, 10, 7, 15), tt(2018, 12, 13, 15, 15)),
-		ts("Mon 19:43", tt(2018, 12, 10, 19, 43), tt(2018, 12, 13, 15, 15)),
+		ts("10:04am EDT", date.Minute, tt(2020, 7, 19, 14, 4), tt(2020, 7, 19)),
+		ts("16:00", date.Minute, tt(2018, 12, 13, 16, 0), tt(2018, 12, 13, 15, 15)),
+		ts("Monday 7:15 AM", date.Minute, tt(2018, 12, 10, 7, 15), tt(2018, 12, 13, 15, 15)),
+		ts("Mon 19:43", date.Minute, tt(2018, 12, 10, 19, 43), tt(2018, 12, 13, 15, 15)),
 
 		// Period is day when time is not present
-		tsd("12th March 2010", tt(2010, 3, 12, 0, 0)),
-		tsd("21-12-19", tt(2019, 12, 21, 0, 0)),
+		ts("12th March 2010", date.Day, tt(2010, 3, 12, 0, 0)),
+		ts("21-12-19", date.Day, tt(2019, 12, 21, 0, 0)),
 	}
 
 	// Prepare config