admin/kubesphere
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Update dependencies (#5518)

Browse Source
This commit is contained in:
hongming
2023-02-12 23:09:20 +08:00
committed by GitHub
parent d3b35fb2da
commit a979342f56
1486 changed files with 126660 additions and 71128 deletions
Download Patch File Download Diff File Expand all files Collapse all files

100
vendor/github.com/open-policy-agent/opa/topdown/time.go generated vendored
View File

@@ -39,14 +39,12 @@ func builtinTimeNowNanos(bctx BuiltinContext, _ []*ast.Term, iter func(*ast.Term
}
func builtinTimeParseNanos(_ BuiltinContext, operands []*ast.Term, iter func(*ast.Term) error) error {
a := operands[0].Value
format, err := builtins.StringOperand(a, 1)
format, err := builtins.StringOperand(operands[0].Value, 1)
if err != nil {
return err
}
b := operands[1].Value
value, err := builtins.StringOperand(b, 2)
value, err := builtins.StringOperand(operands[1].Value, 2)
if err != nil {
return err
}
@@ -60,8 +58,7 @@ func builtinTimeParseNanos(_ BuiltinContext, operands []*ast.Term, iter func(*as
}
func builtinTimeParseRFC3339Nanos(_ BuiltinContext, operands []*ast.Term, iter func(*ast.Term) error) error {
a := operands[0].Value
value, err := builtins.StringOperand(a, 1)
value, err := builtins.StringOperand(operands[0].Value, 1)
if err != nil {
return err
}
@@ -73,50 +70,62 @@ func builtinTimeParseRFC3339Nanos(_ BuiltinContext, operands []*ast.Term, iter f
return toSafeUnixNano(result, iter)
}
func builtinParseDurationNanos(a ast.Value) (ast.Value, error) {
duration, err := builtins.StringOperand(a, 1)
func builtinParseDurationNanos(_ BuiltinContext, operands []*ast.Term, iter func(*ast.Term) error) error {
duration, err := builtins.StringOperand(operands[0].Value, 1)
if err != nil {
return nil, err
return err
}
value, err := time.ParseDuration(string(duration))
if err != nil {
return nil, err
return err
}
return ast.Number(int64ToJSONNumber(int64(value))), nil
return iter(ast.NumberTerm(int64ToJSONNumber(int64(value))))
}
func builtinDate(a ast.Value) (ast.Value, error) {
t, err := tzTime(a)
func builtinFormat(_ BuiltinContext, operands []*ast.Term, iter func(*ast.Term) error) error {
t, layout, err := tzTime(operands[0].Value)
if err != nil {
return nil, err
return err
}
// Using RFC3339Nano time formatting as default
if layout == "" {
layout = time.RFC3339Nano
}
timestamp := t.Format(layout)
return iter(ast.StringTerm(timestamp))
}
func builtinDate(_ BuiltinContext, operands []*ast.Term, iter func(*ast.Term) error) error {
t, _, err := tzTime(operands[0].Value)
if err != nil {
return err
}
year, month, day := t.Date()
result := ast.NewArray(ast.IntNumberTerm(year), ast.IntNumberTerm(int(month)), ast.IntNumberTerm(day))
return result, nil
return iter(ast.NewTerm(result))
}
func builtinClock(a ast.Value) (ast.Value, error) {
t, err := tzTime(a)
func builtinClock(_ BuiltinContext, operands []*ast.Term, iter func(*ast.Term) error) error {
t, _, err := tzTime(operands[0].Value)
if err != nil {
return nil, err
return err
}
hour, minute, second := t.Clock()
result := ast.NewArray(ast.IntNumberTerm(hour), ast.IntNumberTerm(minute), ast.IntNumberTerm(second))
return result, nil
return iter(ast.NewTerm(result))
}
func builtinWeekday(a ast.Value) (ast.Value, error) {
t, err := tzTime(a)
func builtinWeekday(_ BuiltinContext, operands []*ast.Term, iter func(*ast.Term) error) error {
t, _, err := tzTime(operands[0].Value)
if err != nil {
return nil, err
return err
}
weekday := t.Weekday().String()
return ast.String(weekday), nil
return iter(ast.StringTerm(weekday))
}
func builtinAddDate(_ BuiltinContext, operands []*ast.Term, iter func(*ast.Term) error) error {
t, err := tzTime(operands[0].Value)
t, _, err := tzTime(operands[0].Value)
if err != nil {
return err
}
@@ -142,11 +151,11 @@ func builtinAddDate(_ BuiltinContext, operands []*ast.Term, iter func(*ast.Term)
}
func builtinDiff(_ BuiltinContext, operands []*ast.Term, iter func(*ast.Term) error) error {
t1, err := tzTime(operands[0].Value)
t1, _, err := tzTime(operands[0].Value)
if err != nil {
return err
}
t2, err := tzTime(operands[1].Value)
t2, _, err := tzTime(operands[1].Value)
if err != nil {
return err
}
@@ -207,25 +216,25 @@ func builtinDiff(_ BuiltinContext, operands []*ast.Term, iter func(*ast.Term) er
ast.IntNumberTerm(hour), ast.IntNumberTerm(min), ast.IntNumberTerm(sec)))
}
func tzTime(a ast.Value) (t time.Time, err error) {
func tzTime(a ast.Value) (t time.Time, lay string, err error) {
var nVal ast.Value
loc := time.UTC
layout := ""
switch va := a.(type) {
case *ast.Array:
if va.Len() == 0 {
return time.Time{}, builtins.NewOperandTypeErr(1, a, "either number (ns) or [number (ns), string (tz)]")
return time.Time{}, layout, builtins.NewOperandTypeErr(1, a, "either number (ns) or [number (ns), string (tz)]")
}
nVal, err = builtins.NumberOperand(va.Elem(0).Value, 1)
if err != nil {
return time.Time{}, err
return time.Time{}, layout, err
}
if va.Len() > 1 {
tzVal, err := builtins.StringOperand(va.Elem(1).Value, 1)
if err != nil {
return time.Time{}, err
return time.Time{}, layout, err
}
tzName := string(tzVal)
@@ -247,7 +256,7 @@ func tzTime(a ast.Value) (t time.Time, err error) {
loc, err = time.LoadLocation(tzName)
if err != nil {
tzCacheMutex.Unlock()
return time.Time{}, err
return time.Time{}, layout, err
}
tzCache[tzName] = loc
}
@@ -255,27 +264,35 @@ func tzTime(a ast.Value) (t time.Time, err error) {
}
}
if va.Len() > 2 {
lay, err := builtins.StringOperand(va.Elem(2).Value, 1)
if err != nil {
return time.Time{}, layout, err
}
layout = string(lay)
}
case ast.Number:
nVal = a
default:
return time.Time{}, builtins.NewOperandTypeErr(1, a, "either number (ns) or [number (ns), string (tz)]")
return time.Time{}, layout, builtins.NewOperandTypeErr(1, a, "either number (ns) or [number (ns), string (tz)]")
}
value, err := builtins.NumberOperand(nVal, 1)
if err != nil {
return time.Time{}, err
return time.Time{}, layout, err
}
f := builtins.NumberToFloat(value)
i64, acc := f.Int64()
if acc != big.Exact {
return time.Time{}, fmt.Errorf("timestamp too big")
return time.Time{}, layout, fmt.Errorf("timestamp too big")
}
t = time.Unix(0, i64).In(loc)
return t, nil
return t, layout, nil
}
func int64ToJSONNumber(i int64) json.Number {
@@ -286,10 +303,11 @@ func init() {
RegisterBuiltinFunc(ast.NowNanos.Name, builtinTimeNowNanos)
RegisterBuiltinFunc(ast.ParseRFC3339Nanos.Name, builtinTimeParseRFC3339Nanos)
RegisterBuiltinFunc(ast.ParseNanos.Name, builtinTimeParseNanos)
RegisterFunctionalBuiltin1(ast.ParseDurationNanos.Name, builtinParseDurationNanos)
RegisterFunctionalBuiltin1(ast.Date.Name, builtinDate)
RegisterFunctionalBuiltin1(ast.Clock.Name, builtinClock)
RegisterFunctionalBuiltin1(ast.Weekday.Name, builtinWeekday)
RegisterBuiltinFunc(ast.ParseDurationNanos.Name, builtinParseDurationNanos)
RegisterBuiltinFunc(ast.Format.Name, builtinFormat)
RegisterBuiltinFunc(ast.Date.Name, builtinDate)
RegisterBuiltinFunc(ast.Clock.Name, builtinClock)
RegisterBuiltinFunc(ast.Weekday.Name, builtinWeekday)
RegisterBuiltinFunc(ast.AddDate.Name, builtinAddDate)
RegisterBuiltinFunc(ast.Diff.Name, builtinDiff)
tzCacheMutex = &sync.Mutex{}