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
// RandomInt returns a random integer between 0 and limit, inclusive
func RandomInt ( limit int64 ) ( int64 , error ) {
int , err := rand . Int ( rand . Reader , big . NewInt ( limit ) )
if err != nil {
return 0 , err
}
return int . Int64 ( ) , nil
}
const letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
// RandomString generates a random alphanumerical string
func RandomString ( length int64 ) ( string , error ) {
bytes := make ( [ ] byte , length )
limit := int64 ( len ( letters ) )
for i := range bytes {
num , err := RandomInt ( limit )
if err != nil {
return "" , err
}
bytes [ i ] = letters [ num ]
}
return string ( bytes ) , nil
}