2017-01-25 05:43:02 +03:00
// Copyright 2017 The Gitea Authors. All rights reserved.
// Use of this source code is governed by a MIT-style
// license that can be found in the LICENSE file.
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"
2020-11-25 14:20:40 +03:00
"errors"
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"
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
// MergeInto merges pairs of values into a "dict"
func MergeInto ( dict map [ string ] interface { } , values ... interface { } ) ( map [ string ] interface { } , error ) {
for i := 0 ; i < len ( values ) ; i ++ {
switch key := values [ i ] . ( type ) {
case string :
i ++
if i == len ( values ) {
return nil , errors . New ( "specify the key for non array values" )
}
dict [ key ] = values [ i ]
case map [ string ] interface { } :
m := values [ i ] . ( map [ string ] interface { } )
for i , v := range m {
dict [ i ] = v
}
default :
return nil , errors . New ( "dict values must be maps" )
}
}
return dict , nil
}
2021-05-10 09:45:17 +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 )
}