1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
|
// Package durafmt formats time.Duration into a human readable format.
package durafmt
import (
"errors"
"strconv"
"strings"
"time"
)
var (
units = []string{"years", "weeks", "days", "hours", "minutes", "seconds", "milliseconds"}
)
// Durafmt holds the parsed duration and the original input duration.
type Durafmt struct {
duration time.Duration
input string // Used as reference.
}
// Parse creates a new *Durafmt struct, returns error if input is invalid.
func Parse(dinput time.Duration) *Durafmt {
input := dinput.String()
return &Durafmt{dinput, input}
}
// ParseString creates a new *Durafmt struct from a string.
// returns an error if input is invalid.
func ParseString(input string) (*Durafmt, error) {
if input == "0" || input == "-0" {
return nil, errors.New("durafmt: missing unit in duration " + input)
}
duration, err := time.ParseDuration(input)
if err != nil {
return nil, err
}
return &Durafmt{duration, input}, nil
}
// String parses d *Durafmt into a human readable duration.
func (d *Durafmt) String() string {
var duration string
// Check for minus durations.
if string(d.input[0]) == "-" {
duration += "-"
d.duration = -d.duration
}
// Convert duration.
seconds := int64(d.duration.Seconds()) % 60
minutes := int64(d.duration.Minutes()) % 60
hours := int64(d.duration.Hours()) % 24
days := int64(d.duration/(24*time.Hour)) % 365 % 7
// Edge case between 364 and 365 days.
// We need to calculate weeks from what is left from years
leftYearDays := int64(d.duration/(24*time.Hour)) % 365
weeks := leftYearDays / 7
if leftYearDays >= 364 && leftYearDays < 365 {
weeks = 52
}
years := int64(d.duration/(24*time.Hour)) / 365
milliseconds := int64(d.duration/time.Millisecond) -
(seconds * 1000) - (minutes * 60000) - (hours * 3600000) -
(days * 86400000) - (weeks * 604800000) - (years * 31536000000)
// Create a map of the converted duration time.
durationMap := map[string]int64{
"milliseconds": milliseconds,
"seconds": seconds,
"minutes": minutes,
"hours": hours,
"days": days,
"weeks": weeks,
"years": years,
}
// Construct duration string.
for _, u := range units {
v := durationMap[u]
strval := strconv.FormatInt(v, 10)
switch {
// add to the duration string if v > 1.
case v > 1:
duration += strval + " " + u + " "
// remove the plural 's', if v is 1.
case v == 1:
duration += strval + " " + strings.TrimRight(u, "s") + " "
// omit any value with 0s or 0.
case d.duration.String() == "0" || d.duration.String() == "0s":
// note: milliseconds and minutes have the same suffix (m)
// so we have to check if the units match with the suffix.
// check for a suffix that is NOT the milliseconds suffix.
if strings.HasSuffix(d.input, string(u[0])) && !strings.Contains(d.input, "ms") {
// if it happens that the units are milliseconds, skip.
if u == "milliseconds" {
continue
}
duration += strval + " " + u
}
// process milliseconds here.
if u == "milliseconds" {
if strings.Contains(d.input, "ms") {
duration += strval + " " + u
break
}
}
break
// omit any value with 0.
case v == 0:
continue
}
}
// trim any remaining spaces.
duration = strings.TrimSpace(duration)
return duration
}
|
