pkg/time: add FormatDuration

issues: #1469

This change adds a new function to format a duration represented as an
integer in nanoseconds to a compact string representation. The string
representation is used in some applications configuration, I.e.
Prometheus.

It's possible to use CUE's string interpolation to provide a valid
configuration by dividing the nanoseconds by the smallest supported
duration multiplier and appending it's suffix. I.e.
"\(nanoseconds/time.Second)s"`.

But this has the downside that human readers of the resulting
configuration have to convert a duration to a more readable format
before being able to interpret the value inside as part of complete
configuration.

The implementation for this new function is the same as the String()
method of Go's time.Duration type of the standard library.

Signed-off-by: xinau <felix@ehrenpfort.de>
Change-Id: Ibfe455166ebc5f5b8f55f7360cefba1a05eac390
Signed-off-by: xinau <felix@ehrenpfort.de>
Reviewed-on: https://review.gerrithub.io/c/cue-lang/cue/+/531327
Unity-Result: CUEcueckoo <cueckoo@cuelang.org>
TryBot-Result: CUEcueckoo <cueckoo@cuelang.org>
Reviewed-by: Marcel van Lohuizen <mpvl@gmail.com>

Author: xinau

pkg/time/duration.go

@@ -50,6 +50,16 @@ func Duration(s string) (bool, error) {
 	return true, nil
 }
 
+// FormatDuration converts nanoseconds to a string representing the duration in
+// the form "72h3m0.5s".
+//
+// Leading zero units are omitted. As a special case, durations less than
+// one second use a smaller unit (milli-, micro-, or nanoseconds) to ensure
+// that the leading digit is non-zero. The zero duration formats as 0s.
+func FormatDuration(d int64) string {
+	return time.Duration(d).String()
+}
+
 // ParseDuration reports the nanoseconds represented by a duration string.
 //
 // A duration string is a possibly signed sequence of

pkg/time/duration_test.go

@@ -48,6 +48,26 @@ func TestDuration(t *testing.T) {
 	}
 }
 
+func TestFormatDuration(t *testing.T) {
+	valid := []struct {
+		in  int64
+		out string
+	}{
+		{3*Hour + 2*Minute, "3h2m0s"},
+		{5 * Second, "5s"},
+		{600 * Millisecond, "600ms"},
+	}
+
+	for _, tc := range valid {
+		t.Run(tc.out, func(t *testing.T) {
+			s := FormatDuration(tc.in)
+			if s != tc.out {
+				t.Fatalf("got %v; want %v", s, tc.out)
+			}
+		})
+	}
+}
+
 func TestParseDuration(t *testing.T) {
 	valid := []struct {
 		in  string

pkg/time/pkg.go

@@ -0,0 +1,41 @@
+// Copyright 2022 CUE Authors
+//
+// 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.
+
+
+-- in.cue --
+import "time"
+
+FormatDuration: [...{
+    arg: int
+    out: time.FormatDuration(arg)
+}]
+
+FormatDuration: [
+    {arg: 10920000000000},
+    {arg: 5000000000},
+    {arg: 600000000},
+]
+
+-- out/time --
+FormatDuration: [{
+	arg: 10920000000000
+	out: "3h2m0s"
+}, {
+	arg: 5000000000
+	out: "5s"
+}, {
+	arg: 600000000
+	out: "600ms"
+}]
+