mirror of
https://codeberg.org/scip/ts.git
synced 2026-08-24 06:44:19 +02:00
add expr-lang.org support (use with -e)
This commit is contained in:
142
pkg/runexpr/duration.go
Normal file
142
pkg/runexpr/duration.go
Normal file
@@ -0,0 +1,142 @@
|
||||
package runexpr
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"log"
|
||||
"math"
|
||||
"strconv"
|
||||
"time"
|
||||
)
|
||||
|
||||
const maxDuration time.Duration = 1<<63 - 1
|
||||
|
||||
// humanDuration represents a ES duration with day support
|
||||
type humanDuration struct {
|
||||
days, hours, minutes, seconds int
|
||||
}
|
||||
|
||||
func parseDuration(duration string) time.Duration {
|
||||
var seconds int64
|
||||
|
||||
for _, match := range matchDuration.FindAllStringSubmatch(duration, -1) {
|
||||
if len(match) == 3 {
|
||||
durationvalue, err := strconv.ParseInt(match[1], 10, 64)
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
|
||||
switch match[2][0] {
|
||||
case 'y':
|
||||
seconds += durationvalue * 31536000
|
||||
case 'd':
|
||||
seconds += durationvalue * 86400
|
||||
case 'h':
|
||||
seconds += durationvalue * 3600
|
||||
case 'm':
|
||||
seconds += durationvalue * 60
|
||||
case 's':
|
||||
seconds += durationvalue
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if seconds >= int64(maxDuration.Seconds()) {
|
||||
log.Fatal("duration overflow, choose a smaller duration")
|
||||
}
|
||||
|
||||
dur := time.Duration(seconds) * time.Second
|
||||
|
||||
return dur
|
||||
}
|
||||
|
||||
// extractDuration parses a ES duration and returns an esDuration
|
||||
func extractDuration(duration string) humanDuration {
|
||||
esd := humanDuration{}
|
||||
|
||||
for _, match := range matchDuration.FindAllStringSubmatch(duration, -1) {
|
||||
if len(match) == 3 {
|
||||
durationvalue, _ := strconv.Atoi(match[1])
|
||||
|
||||
switch match[2][0] {
|
||||
case 'd':
|
||||
esd.days = durationvalue
|
||||
case 'h':
|
||||
esd.hours = durationvalue
|
||||
case 'm':
|
||||
esd.minutes = durationvalue
|
||||
case 's':
|
||||
esd.seconds = durationvalue
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return esd
|
||||
}
|
||||
|
||||
// formatDays returns days string, unless days is larger than 365,
|
||||
// then it returns years and days, e.g. 3y/34d
|
||||
func formatDays(days float64) string {
|
||||
if days > 365 {
|
||||
years := days / 365
|
||||
days := math.Remainder(days, 365)
|
||||
return fmt.Sprintf("%dy/%dd", int64(years), int64(days))
|
||||
}
|
||||
|
||||
return fmt.Sprintf("%dd", int64(days))
|
||||
}
|
||||
|
||||
// formatDuration converts a time.Duration to a prettier human
|
||||
// readable form, like 156h6m15.095s-6d/12h/6m => 6d/12h/6m
|
||||
func formatDuration(val time.Duration) string {
|
||||
esd := extractDuration(val.String())
|
||||
|
||||
daysF := float64(esd.hours) / 24.0
|
||||
days := math.Floor(daysF)
|
||||
hoursLeft := (daysF - days) * 24
|
||||
|
||||
switch {
|
||||
case val.Minutes() < 1:
|
||||
return fmt.Sprintf("%ds", int64(esd.seconds))
|
||||
|
||||
case val.Hours() < 1:
|
||||
return fmt.Sprintf("%dm", int64(esd.minutes))
|
||||
|
||||
case val.Hours() < 24:
|
||||
if esd.minutes == 0 {
|
||||
return fmt.Sprintf("%dh", esd.hours)
|
||||
}
|
||||
|
||||
return fmt.Sprintf("%dh/%dm", esd.hours, int64(esd.minutes))
|
||||
|
||||
default:
|
||||
if esd.minutes == 0 && hoursLeft == 0 {
|
||||
return formatDays(days)
|
||||
}
|
||||
|
||||
return fmt.Sprintf("%s/%dh/%dm",
|
||||
formatDays(days),
|
||||
int64(hoursLeft),
|
||||
esd.minutes,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
func toYears(d time.Duration) float64 {
|
||||
return d.Hours() / 24 / 365
|
||||
}
|
||||
|
||||
func toDays(d time.Duration) float64 {
|
||||
return d.Hours() / 24
|
||||
}
|
||||
|
||||
func toHours(d time.Duration) float64 {
|
||||
return d.Hours()
|
||||
}
|
||||
|
||||
func toMinutes(d time.Duration) float64 {
|
||||
return d.Minutes()
|
||||
}
|
||||
|
||||
func toSeconds(d time.Duration) float64 {
|
||||
return d.Seconds()
|
||||
}
|
||||
63
pkg/runexpr/run.go
Normal file
63
pkg/runexpr/run.go
Normal file
@@ -0,0 +1,63 @@
|
||||
package runexpr
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"time"
|
||||
|
||||
"github.com/expr-lang/expr"
|
||||
)
|
||||
|
||||
type Env struct {
|
||||
Now func() time.Time
|
||||
Dur, D func(string) time.Duration
|
||||
Strf func(any, ...any) string
|
||||
Diff func(a, b time.Time) time.Duration
|
||||
Add func(time.Time, time.Duration) time.Time
|
||||
Time, T func(string, ...string) time.Time
|
||||
Human func(time.Duration) string
|
||||
Years, Days, Hours, Minutes, Seconds func(time.Duration) float64
|
||||
Clock func(time.Time) string
|
||||
Unix func(time.Time) int64
|
||||
TZ func(time.Time, any) time.Time
|
||||
}
|
||||
|
||||
func RunExpr(code string) {
|
||||
env := Env{
|
||||
Now: time.Now,
|
||||
Dur: parseDuration,
|
||||
D: parseDuration,
|
||||
Strf: strfTime,
|
||||
Diff: timeDiff,
|
||||
Add: timeAdd,
|
||||
Time: newTime,
|
||||
T: newTime,
|
||||
Human: formatDuration,
|
||||
Years: toYears,
|
||||
Days: toDays,
|
||||
Hours: toHours,
|
||||
Minutes: toMinutes,
|
||||
Seconds: toSeconds,
|
||||
Clock: toClock,
|
||||
Unix: toUnix,
|
||||
TZ: toTZ,
|
||||
}
|
||||
|
||||
options := []expr.Option{
|
||||
expr.Env(Env{}),
|
||||
expr.Operator("-", "Diff"), // custom operator to diff two time.Time's
|
||||
expr.Operator("+", "Add"), // custom operator to add time.Duration to a time.Time
|
||||
}
|
||||
|
||||
program, err := expr.Compile(code, options...)
|
||||
if err != nil {
|
||||
fmt.Printf("%v", err)
|
||||
return
|
||||
}
|
||||
|
||||
output, err := expr.Run(program, env)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
|
||||
fmt.Println(output)
|
||||
}
|
||||
159
pkg/runexpr/time.go
Normal file
159
pkg/runexpr/time.go
Normal file
@@ -0,0 +1,159 @@
|
||||
package runexpr
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"log"
|
||||
"reflect"
|
||||
"regexp"
|
||||
"time"
|
||||
|
||||
"github.com/lestrrat-go/strftime"
|
||||
)
|
||||
|
||||
var (
|
||||
// matchDuration is a regex which matches ES durations, which
|
||||
// supports days (in contrast to time.Duration which does not)
|
||||
matchDuration = regexp.MustCompile(`(\d+)([ydhms])`)
|
||||
|
||||
timeFormats = []string{
|
||||
time.RFC3339,
|
||||
time.RFC1123Z,
|
||||
time.RFC1123,
|
||||
time.RFC850,
|
||||
time.RFC822Z,
|
||||
time.RFC822,
|
||||
time.RubyDate,
|
||||
time.UnixDate,
|
||||
time.DateTime,
|
||||
time.DateOnly,
|
||||
time.TimeOnly,
|
||||
"02.01.2006 15:04:05", // german
|
||||
"02/01/2006 15:04:05",
|
||||
"20060102",
|
||||
"02.01.2006", // german
|
||||
"20060102150405",
|
||||
"15:04:05",
|
||||
"15:04",
|
||||
}
|
||||
)
|
||||
|
||||
// setDefault# either returns the first element if item if set or
|
||||
// replace. Types must match expect.
|
||||
func setDefault(item []any, replace any, expect reflect.Type) any {
|
||||
if reflect.TypeOf(replace) != expect {
|
||||
log.Fatal("setDefault(): invalid types called")
|
||||
}
|
||||
|
||||
if len(item) == 1 {
|
||||
return item[0]
|
||||
} else {
|
||||
return replace
|
||||
}
|
||||
}
|
||||
|
||||
// strfTime formats a time.Time. Args are any,any to be able to use it in a pipe.
|
||||
//
|
||||
// eg:
|
||||
//
|
||||
// now | strftime("%D")
|
||||
// strftime(now, "%D")
|
||||
// "%d.%m" | strftime(now)
|
||||
func strfTime(fst any, snd ...any) string {
|
||||
var ts time.Time
|
||||
var format string
|
||||
|
||||
switch firstVal := fst.(type) {
|
||||
case string:
|
||||
format = firstVal
|
||||
ts = setDefault(snd, time.Now(), reflect.TypeFor[time.Time]()).(time.Time)
|
||||
case time.Time:
|
||||
ts = firstVal
|
||||
format = setDefault(snd, "%D", reflect.TypeFor[string]()).(string)
|
||||
}
|
||||
|
||||
if format == "" || ts.IsZero() {
|
||||
log.Fatal("strftime(): invalid args")
|
||||
}
|
||||
|
||||
formatted, err := strftime.Format(format, ts)
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
|
||||
return formatted
|
||||
}
|
||||
|
||||
// timeDiff returns the time.Duration diff between time.Time a and
|
||||
// b. It syncs timezones first and exchanges a+b if a>b
|
||||
func timeDiff(a, b time.Time) time.Duration {
|
||||
if a.Location() != b.Location() {
|
||||
b = b.In(a.Location())
|
||||
}
|
||||
|
||||
if a.After(b) {
|
||||
a, b = b, a
|
||||
}
|
||||
|
||||
return b.Sub(a)
|
||||
}
|
||||
|
||||
// newTime returns a new tim.Time object if ts matches one of the
|
||||
// predefined formats. If format is set, use this.
|
||||
func newTime(ts string, format ...string) time.Time {
|
||||
if len(format) > 0 {
|
||||
t, err := time.Parse(format[0], ts)
|
||||
if err == nil {
|
||||
return t
|
||||
}
|
||||
}
|
||||
for _, format := range timeFormats {
|
||||
t, err := time.Parse(format, ts)
|
||||
if err == nil {
|
||||
return t
|
||||
}
|
||||
}
|
||||
|
||||
log.Fatal("new(): failed to parse timestamp")
|
||||
|
||||
return time.Time{}
|
||||
}
|
||||
|
||||
// toClock returns the HH:MM:SS time part of a time.Time
|
||||
func toClock(t time.Time) string {
|
||||
h, m, s := t.Clock()
|
||||
return fmt.Sprintf("%02d:%02d:%02d", h, m, s)
|
||||
}
|
||||
|
||||
// timeAdd adds d to t
|
||||
func timeAdd(t time.Time, d time.Duration) time.Time {
|
||||
return t.Add(d)
|
||||
}
|
||||
|
||||
// toUnix returns the epoch of t
|
||||
func toUnix(t time.Time) int64 {
|
||||
return t.Unix()
|
||||
}
|
||||
|
||||
// toTZ converts t to given time zone
|
||||
func toTZ(t time.Time, tz any) time.Time {
|
||||
var z *time.Location
|
||||
var err error
|
||||
|
||||
switch val := tz.(type) {
|
||||
case string:
|
||||
z, err = time.LoadLocation(val)
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
|
||||
case int:
|
||||
f := fmt.Sprintf("UTC+%d", val)
|
||||
if val < 0 {
|
||||
f = fmt.Sprintf("UTC%d", val)
|
||||
}
|
||||
|
||||
z = time.FixedZone(f, val*60*60)
|
||||
}
|
||||
|
||||
return t.In(z)
|
||||
}
|
||||
Reference in New Issue
Block a user