2017-01-25 05:43:02 +03:00
// Copyright 2017 The Gitea Authors. All rights reserved.
2022-11-27 21:20:29 +03:00
// SPDX-License-Identifier: MIT
2017-01-25 05:43:02 +03:00
package util
2018-02-20 15:50:42 +03:00
import (
2019-11-13 05:27:11 +03:00
"bytes"
2021-05-10 09:45:17 +03:00
"crypto/rand"
2023-04-03 19:58:09 +03:00
"fmt"
2021-05-10 09:45:17 +03:00
"math/big"
2021-10-12 21:11:35 +03:00
"strconv"
2018-05-29 06:51:42 +03:00
"strings"
2022-05-11 00:55:54 +03:00
"golang.org/x/text/cases"
"golang.org/x/text/language"
2018-02-20 15:50:42 +03:00
)
2017-01-25 05:43:02 +03:00
// OptionalBool a boolean that can be "null"
type OptionalBool byte
const (
// OptionalBoolNone a "null" boolean value
2021-10-12 21:11:35 +03:00
OptionalBoolNone OptionalBool = iota
2017-01-25 05:43:02 +03:00
// OptionalBoolTrue a "true" boolean value
OptionalBoolTrue
// OptionalBoolFalse a "false" boolean value
OptionalBoolFalse
)
2017-10-24 20:36:19 +03:00
// IsTrue return true if equal to OptionalBoolTrue
func ( o OptionalBool ) IsTrue ( ) bool {
return o == OptionalBoolTrue
}
// IsFalse return true if equal to OptionalBoolFalse
func ( o OptionalBool ) IsFalse ( ) bool {
return o == OptionalBoolFalse
}
// IsNone return true if equal to OptionalBoolNone
func ( o OptionalBool ) IsNone ( ) bool {
return o == OptionalBoolNone
}
2017-01-25 05:43:02 +03:00
// OptionalBoolOf get the corresponding OptionalBool of a bool
func OptionalBoolOf ( b bool ) OptionalBool {
if b {
return OptionalBoolTrue
}
return OptionalBoolFalse
}
2017-10-27 09:10:54 +03:00
2021-10-12 21:11:35 +03:00
// OptionalBoolParse get the corresponding OptionalBool of a string using strconv.ParseBool
func OptionalBoolParse ( s string ) OptionalBool {
b , e := strconv . ParseBool ( s )
if e != nil {
return OptionalBoolNone
}
return OptionalBoolOf ( b )
}
2017-10-27 09:10:54 +03:00
// Max max of two ints
func Max ( a , b int ) int {
if a < b {
return b
}
return a
}
// Min min of two ints
func Min ( a , b int ) int {
if a > b {
return b
}
return a
}
2019-01-21 14:45:32 +03:00
// IsEmptyString checks if the provided string is empty
func IsEmptyString ( s string ) bool {
return len ( strings . TrimSpace ( s ) ) == 0
}
2019-11-13 05:27:11 +03:00
// NormalizeEOL will convert Windows (CRLF) and Mac (CR) EOLs to UNIX (LF)
func NormalizeEOL ( input [ ] byte ) [ ] byte {
var right , left , pos int
if right = bytes . IndexByte ( input , '\r' ) ; right == - 1 {
return input
}
length := len ( input )
tmp := make ( [ ] byte , length )
// We know that left < length because otherwise right would be -1 from IndexByte.
copy ( tmp [ pos : pos + right ] , input [ left : left + right ] )
pos += right
tmp [ pos ] = '\n'
left += right + 1
pos ++
for left < length {
if input [ left ] == '\n' {
left ++
}
right = bytes . IndexByte ( input [ left : ] , '\r' )
if right == - 1 {
copy ( tmp [ pos : ] , input [ left : ] )
pos += length - left
break
}
copy ( tmp [ pos : pos + right ] , input [ left : left + right ] )
pos += right
tmp [ pos ] = '\n'
left += right + 1
pos ++
}
return tmp [ : pos ]
}
2020-11-25 14:20:40 +03:00
2022-01-26 07:10:10 +03:00
// CryptoRandomInt returns a crypto random integer between 0 and limit, inclusive
func CryptoRandomInt ( limit int64 ) ( int64 , error ) {
2022-01-04 18:13:52 +03:00
rInt , err := rand . Int ( rand . Reader , big . NewInt ( limit ) )
2021-05-10 09:45:17 +03:00
if err != nil {
return 0 , err
}
2022-01-04 18:13:52 +03:00
return rInt . Int64 ( ) , nil
2021-05-10 09:45:17 +03:00
}
2022-01-26 07:10:10 +03:00
const alphanumericalChars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
2021-05-10 09:45:17 +03:00
2022-01-26 07:10:10 +03:00
// CryptoRandomString generates a crypto random alphanumerical string, each byte is generated by [0,61] range
func CryptoRandomString ( length int64 ) ( string , error ) {
buf := make ( [ ] byte , length )
limit := int64 ( len ( alphanumericalChars ) )
for i := range buf {
num , err := CryptoRandomInt ( limit )
2021-05-10 09:45:17 +03:00
if err != nil {
return "" , err
}
2022-01-26 07:10:10 +03:00
buf [ i ] = alphanumericalChars [ num ]
2021-05-10 09:45:17 +03:00
}
2022-01-26 07:10:10 +03:00
return string ( buf ) , nil
2021-05-10 09:45:17 +03:00
}
2022-01-04 18:13:52 +03:00
2022-01-26 07:10:10 +03:00
// CryptoRandomBytes generates `length` crypto bytes
// This differs from CryptoRandomString, as each byte in CryptoRandomString is generated by [0,61] range
// This function generates totally random bytes, each byte is generated by [0,255] range
func CryptoRandomBytes ( length int64 ) ( [ ] byte , error ) {
buf := make ( [ ] byte , length )
_ , err := rand . Read ( buf )
return buf , err
2022-01-04 18:13:52 +03:00
}
2022-02-01 15:59:25 +03:00
// ToUpperASCII returns s with all ASCII letters mapped to their upper case.
func ToUpperASCII ( s string ) string {
b := [ ] byte ( s )
for i , c := range b {
if 'a' <= c && c <= 'z' {
b [ i ] -= 'a' - 'A'
}
}
return string ( b )
}
2022-05-11 00:55:54 +03:00
// ToTitleCase returns s with all english words capitalized
func ToTitleCase ( s string ) string {
2023-04-04 01:03:45 +03:00
// `cases.Title` is not thread-safe, do not use global shared variable for it
return cases . Title ( language . English ) . String ( s )
2022-05-11 00:55:54 +03:00
}
2022-06-10 16:45:28 +03:00
2023-04-04 01:03:45 +03:00
// ToTitleCaseNoLower returns s with all english words capitalized without lower-casing
2022-11-19 14:08:06 +03:00
func ToTitleCaseNoLower ( s string ) string {
2023-04-04 01:03:45 +03:00
// `cases.Title` is not thread-safe, do not use global shared variable for it
return cases . Title ( language . English , cases . NoLower ) . String ( s )
2022-11-19 14:08:06 +03:00
}
2023-04-03 19:58:09 +03:00
// ToInt64 transform a given int into int64.
Use a general Eval function for expressions in templates. (#23927)
One of the proposals in #23328
This PR introduces a simple expression calculator
(templates/eval/eval.go), it can do basic expression calculations.
Many untested template helper functions like `Mul` `Add` can be replaced
by this new approach.
Then these `Add` / `Mul` / `percentage` / `Subtract` / `DiffStatsWidth`
could all use this `Eval`.
And it provides enhancements for Golang templates, and improves
readability.
Some examples:
----
* Before: `{{Add (Mul $glyph.Row 12) 12}}`
* After: `{{Eval $glyph.Row "*" 12 "+" 12}}`
----
* Before: `{{if lt (Add $i 1) (len $.Topics)}}`
* After: `{{if Eval $i "+" 1 "<" (len $.Topics)}}`
## FAQ
### Why not use an existing expression package?
We need a highly customized expression engine:
* do the calculation on the fly, without pre-compiling
* deal with int/int64/float64 types, to make the result could be used in
Golang template.
* make the syntax could be used in the Golang template directly
* do not introduce too much complex or strange syntax, we just need a
simple calculator.
* it needs to strictly follow Golang template's behavior, for example,
Golang template treats all non-zero values as truth, but many 3rd
packages don't do so.
### What's the benefit?
* Developers don't need to add more `Add`/`Mul`/`Sub`-like functions,
they were getting more and more.
Now, only one `Eval` is enough for all cases.
* The new code reads better than old `{{Add (Mul $glyph.Row 12) 12}}`,
the old one isn't familiar to most procedural programming developers
(eg, the Golang expression syntax).
* The `Eval` is fully covered by tests, many old `Add`/`Mul`-like
functions were never tested.
### The performance?
It doesn't use `reflect`, it doesn't need to parse or compile when used
in Golang template, the performance is as fast as native Go template.
### Is it too complex? Could it be unstable?
The expression calculator program is a common homework for computer
science students, and it's widely used as a teaching and practicing
purpose for developers. The algorithm is pretty well-known.
The behavior can be clearly defined, it is stable.
2023-04-07 16:25:49 +03:00
func ToInt64 ( number interface { } ) ( int64 , error ) {
2022-06-12 15:08:23 +03:00
var value int64
switch v := number . ( type ) {
case int :
value = int64 ( v )
case int8 :
value = int64 ( v )
case int16 :
value = int64 ( v )
case int32 :
value = int64 ( v )
case int64 :
value = v
Use a general Eval function for expressions in templates. (#23927)
One of the proposals in #23328
This PR introduces a simple expression calculator
(templates/eval/eval.go), it can do basic expression calculations.
Many untested template helper functions like `Mul` `Add` can be replaced
by this new approach.
Then these `Add` / `Mul` / `percentage` / `Subtract` / `DiffStatsWidth`
could all use this `Eval`.
And it provides enhancements for Golang templates, and improves
readability.
Some examples:
----
* Before: `{{Add (Mul $glyph.Row 12) 12}}`
* After: `{{Eval $glyph.Row "*" 12 "+" 12}}`
----
* Before: `{{if lt (Add $i 1) (len $.Topics)}}`
* After: `{{if Eval $i "+" 1 "<" (len $.Topics)}}`
## FAQ
### Why not use an existing expression package?
We need a highly customized expression engine:
* do the calculation on the fly, without pre-compiling
* deal with int/int64/float64 types, to make the result could be used in
Golang template.
* make the syntax could be used in the Golang template directly
* do not introduce too much complex or strange syntax, we just need a
simple calculator.
* it needs to strictly follow Golang template's behavior, for example,
Golang template treats all non-zero values as truth, but many 3rd
packages don't do so.
### What's the benefit?
* Developers don't need to add more `Add`/`Mul`/`Sub`-like functions,
they were getting more and more.
Now, only one `Eval` is enough for all cases.
* The new code reads better than old `{{Add (Mul $glyph.Row 12) 12}}`,
the old one isn't familiar to most procedural programming developers
(eg, the Golang expression syntax).
* The `Eval` is fully covered by tests, many old `Add`/`Mul`-like
functions were never tested.
### The performance?
It doesn't use `reflect`, it doesn't need to parse or compile when used
in Golang template, the performance is as fast as native Go template.
### Is it too complex? Could it be unstable?
The expression calculator program is a common homework for computer
science students, and it's widely used as a teaching and practicing
purpose for developers. The algorithm is pretty well-known.
The behavior can be clearly defined, it is stable.
2023-04-07 16:25:49 +03:00
2023-04-03 19:58:09 +03:00
case uint :
value = int64 ( v )
case uint8 :
value = int64 ( v )
case uint16 :
value = int64 ( v )
case uint32 :
value = int64 ( v )
case uint64 :
value = int64 ( v )
Use a general Eval function for expressions in templates. (#23927)
One of the proposals in #23328
This PR introduces a simple expression calculator
(templates/eval/eval.go), it can do basic expression calculations.
Many untested template helper functions like `Mul` `Add` can be replaced
by this new approach.
Then these `Add` / `Mul` / `percentage` / `Subtract` / `DiffStatsWidth`
could all use this `Eval`.
And it provides enhancements for Golang templates, and improves
readability.
Some examples:
----
* Before: `{{Add (Mul $glyph.Row 12) 12}}`
* After: `{{Eval $glyph.Row "*" 12 "+" 12}}`
----
* Before: `{{if lt (Add $i 1) (len $.Topics)}}`
* After: `{{if Eval $i "+" 1 "<" (len $.Topics)}}`
## FAQ
### Why not use an existing expression package?
We need a highly customized expression engine:
* do the calculation on the fly, without pre-compiling
* deal with int/int64/float64 types, to make the result could be used in
Golang template.
* make the syntax could be used in the Golang template directly
* do not introduce too much complex or strange syntax, we just need a
simple calculator.
* it needs to strictly follow Golang template's behavior, for example,
Golang template treats all non-zero values as truth, but many 3rd
packages don't do so.
### What's the benefit?
* Developers don't need to add more `Add`/`Mul`/`Sub`-like functions,
they were getting more and more.
Now, only one `Eval` is enough for all cases.
* The new code reads better than old `{{Add (Mul $glyph.Row 12) 12}}`,
the old one isn't familiar to most procedural programming developers
(eg, the Golang expression syntax).
* The `Eval` is fully covered by tests, many old `Add`/`Mul`-like
functions were never tested.
### The performance?
It doesn't use `reflect`, it doesn't need to parse or compile when used
in Golang template, the performance is as fast as native Go template.
### Is it too complex? Could it be unstable?
The expression calculator program is a common homework for computer
science students, and it's widely used as a teaching and practicing
purpose for developers. The algorithm is pretty well-known.
The behavior can be clearly defined, it is stable.
2023-04-07 16:25:49 +03:00
case float32 :
value = int64 ( v )
case float64 :
value = int64 ( v )
2023-04-03 19:58:09 +03:00
case string :
var err error
if value , err = strconv . ParseInt ( v , 10 , 64 ) ; err != nil {
Use a general Eval function for expressions in templates. (#23927)
One of the proposals in #23328
This PR introduces a simple expression calculator
(templates/eval/eval.go), it can do basic expression calculations.
Many untested template helper functions like `Mul` `Add` can be replaced
by this new approach.
Then these `Add` / `Mul` / `percentage` / `Subtract` / `DiffStatsWidth`
could all use this `Eval`.
And it provides enhancements for Golang templates, and improves
readability.
Some examples:
----
* Before: `{{Add (Mul $glyph.Row 12) 12}}`
* After: `{{Eval $glyph.Row "*" 12 "+" 12}}`
----
* Before: `{{if lt (Add $i 1) (len $.Topics)}}`
* After: `{{if Eval $i "+" 1 "<" (len $.Topics)}}`
## FAQ
### Why not use an existing expression package?
We need a highly customized expression engine:
* do the calculation on the fly, without pre-compiling
* deal with int/int64/float64 types, to make the result could be used in
Golang template.
* make the syntax could be used in the Golang template directly
* do not introduce too much complex or strange syntax, we just need a
simple calculator.
* it needs to strictly follow Golang template's behavior, for example,
Golang template treats all non-zero values as truth, but many 3rd
packages don't do so.
### What's the benefit?
* Developers don't need to add more `Add`/`Mul`/`Sub`-like functions,
they were getting more and more.
Now, only one `Eval` is enough for all cases.
* The new code reads better than old `{{Add (Mul $glyph.Row 12) 12}}`,
the old one isn't familiar to most procedural programming developers
(eg, the Golang expression syntax).
* The `Eval` is fully covered by tests, many old `Add`/`Mul`-like
functions were never tested.
### The performance?
It doesn't use `reflect`, it doesn't need to parse or compile when used
in Golang template, the performance is as fast as native Go template.
### Is it too complex? Could it be unstable?
The expression calculator program is a common homework for computer
science students, and it's widely used as a teaching and practicing
purpose for developers. The algorithm is pretty well-known.
The behavior can be clearly defined, it is stable.
2023-04-07 16:25:49 +03:00
return 0 , err
}
default :
return 0 , fmt . Errorf ( "unable to convert %v to int64" , number )
}
return value , nil
}
// ToFloat64 transform a given int into float64.
func ToFloat64 ( number interface { } ) ( float64 , error ) {
var value float64
switch v := number . ( type ) {
case int :
value = float64 ( v )
case int8 :
value = float64 ( v )
case int16 :
value = float64 ( v )
case int32 :
value = float64 ( v )
case int64 :
value = float64 ( v )
case uint :
value = float64 ( v )
case uint8 :
value = float64 ( v )
case uint16 :
value = float64 ( v )
case uint32 :
value = float64 ( v )
case uint64 :
value = float64 ( v )
case float32 :
value = float64 ( v )
case float64 :
value = v
case string :
var err error
if value , err = strconv . ParseFloat ( v , 64 ) ; err != nil {
return 0 , err
2023-04-03 19:58:09 +03:00
}
default :
Use a general Eval function for expressions in templates. (#23927)
One of the proposals in #23328
This PR introduces a simple expression calculator
(templates/eval/eval.go), it can do basic expression calculations.
Many untested template helper functions like `Mul` `Add` can be replaced
by this new approach.
Then these `Add` / `Mul` / `percentage` / `Subtract` / `DiffStatsWidth`
could all use this `Eval`.
And it provides enhancements for Golang templates, and improves
readability.
Some examples:
----
* Before: `{{Add (Mul $glyph.Row 12) 12}}`
* After: `{{Eval $glyph.Row "*" 12 "+" 12}}`
----
* Before: `{{if lt (Add $i 1) (len $.Topics)}}`
* After: `{{if Eval $i "+" 1 "<" (len $.Topics)}}`
## FAQ
### Why not use an existing expression package?
We need a highly customized expression engine:
* do the calculation on the fly, without pre-compiling
* deal with int/int64/float64 types, to make the result could be used in
Golang template.
* make the syntax could be used in the Golang template directly
* do not introduce too much complex or strange syntax, we just need a
simple calculator.
* it needs to strictly follow Golang template's behavior, for example,
Golang template treats all non-zero values as truth, but many 3rd
packages don't do so.
### What's the benefit?
* Developers don't need to add more `Add`/`Mul`/`Sub`-like functions,
they were getting more and more.
Now, only one `Eval` is enough for all cases.
* The new code reads better than old `{{Add (Mul $glyph.Row 12) 12}}`,
the old one isn't familiar to most procedural programming developers
(eg, the Golang expression syntax).
* The `Eval` is fully covered by tests, many old `Add`/`Mul`-like
functions were never tested.
### The performance?
It doesn't use `reflect`, it doesn't need to parse or compile when used
in Golang template, the performance is as fast as native Go template.
### Is it too complex? Could it be unstable?
The expression calculator program is a common homework for computer
science students, and it's widely used as a teaching and practicing
purpose for developers. The algorithm is pretty well-known.
The behavior can be clearly defined, it is stable.
2023-04-07 16:25:49 +03:00
return 0 , fmt . Errorf ( "unable to convert %v to float64" , number )
2022-06-12 15:08:23 +03:00
}
Use a general Eval function for expressions in templates. (#23927)
One of the proposals in #23328
This PR introduces a simple expression calculator
(templates/eval/eval.go), it can do basic expression calculations.
Many untested template helper functions like `Mul` `Add` can be replaced
by this new approach.
Then these `Add` / `Mul` / `percentage` / `Subtract` / `DiffStatsWidth`
could all use this `Eval`.
And it provides enhancements for Golang templates, and improves
readability.
Some examples:
----
* Before: `{{Add (Mul $glyph.Row 12) 12}}`
* After: `{{Eval $glyph.Row "*" 12 "+" 12}}`
----
* Before: `{{if lt (Add $i 1) (len $.Topics)}}`
* After: `{{if Eval $i "+" 1 "<" (len $.Topics)}}`
## FAQ
### Why not use an existing expression package?
We need a highly customized expression engine:
* do the calculation on the fly, without pre-compiling
* deal with int/int64/float64 types, to make the result could be used in
Golang template.
* make the syntax could be used in the Golang template directly
* do not introduce too much complex or strange syntax, we just need a
simple calculator.
* it needs to strictly follow Golang template's behavior, for example,
Golang template treats all non-zero values as truth, but many 3rd
packages don't do so.
### What's the benefit?
* Developers don't need to add more `Add`/`Mul`/`Sub`-like functions,
they were getting more and more.
Now, only one `Eval` is enough for all cases.
* The new code reads better than old `{{Add (Mul $glyph.Row 12) 12}}`,
the old one isn't familiar to most procedural programming developers
(eg, the Golang expression syntax).
* The `Eval` is fully covered by tests, many old `Add`/`Mul`-like
functions were never tested.
### The performance?
It doesn't use `reflect`, it doesn't need to parse or compile when used
in Golang template, the performance is as fast as native Go template.
### Is it too complex? Could it be unstable?
The expression calculator program is a common homework for computer
science students, and it's widely used as a teaching and practicing
purpose for developers. The algorithm is pretty well-known.
The behavior can be clearly defined, it is stable.
2023-04-07 16:25:49 +03:00
return value , nil
2022-06-12 15:08:23 +03:00
}