ErfanTech
/
niki
forked from ebhomengo/niki
1
0
Fork 0
Code Issues Pull Requests 1 Actions Activity

fix(docker): change port redis

This commit is contained in:
mehdi 2024-04-26 23:00:35 +03:30
parent 235283284f
commit 9fc2b59014
196 changed files with 29755 additions and 503 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -24,3 +24,4 @@ bin
*.env
logs/
mise.log

2
config.yml
View File

@ -15,7 +15,7 @@ mysql:
password: nikiappt0lk2o20
redis:
port: 6380
port: 6379
host: niki-redis
password: ""
db: 0

7
config/test.yml
View File

@ -1,7 +0,0 @@
debug: false
multi_word_var: "I'm complex in config.yml"
db:
host: "localhost"
username: "ali"
password: "passwd"
multi_word_nested_var: "WHAT??"

27
pkg/supervisor/supervisor.go
View File

@ -2,17 +2,17 @@ package supervisor
import (
"context"
"git.gocasts.ir/ebhomengo/niki/logger"
"log/slog"
"os"
"os/signal"
"sync"
"time"
"git.gocasts.ir/ebhomengo/niki/logger"
)
// ProcessFunc is a long-running process which listens on finishSignal
// It notifies the supervisor by terminate channel when it terminates
// It notifies the supervisor by terminate channel when it terminates.
type ProcessFunc func(finishSignal context.Context, processName string, terminateChannel chan<- string) error
var noopProcessFunc = func(finishSignal context.Context, processName string, terminateChannel chan<- string) error {
@ -20,7 +20,7 @@ var noopProcessFunc = func(finishSignal context.Context, processName string, ter
}
// Supervisor is responsible to manage long-running processes
// Supervisor is not for concurrent use and should be used as the main goroutine of application
// Supervisor is not for concurrent use and should be used as the main goroutine of application.
type Supervisor struct {
logger *slog.Logger
lock *sync.Mutex
@ -53,6 +53,7 @@ func New(shutdownTimeout time.Duration, l *slog.Logger) *Supervisor {
ctxCancel: cancel,
shutdownTimeout: shutdownTimeout,
// TODO : how to set terminateChannel buffer?
//nolint
terminateChannel: make(chan string, 10),
}
}
@ -96,7 +97,7 @@ var defaultOptions = ProcessOption{
IsFatal: true,
}
// Register registers a new process to supervisor
// Register registers a new process to supervisor.
func (s *Supervisor) Register(name string, process ProcessFunc, options *ProcessOption) {
// TODO : don't allow any registration after Start is called using a mutex
@ -120,7 +121,7 @@ func (s *Supervisor) Register(name string, process ProcessFunc, options *Process
}
// Start spawns a new goroutine for each process
// Spawned goroutine is responsible to handle the panics and restart the process
// Spawned goroutine is responsible to handle the panics and restart the process.
func (s *Supervisor) Start() {
// TODO : is it viable to use a goroutine pool such as Ants ?
for name := range s.processes {
@ -140,6 +141,7 @@ func (s *Supervisor) executeProcessWithRetryPolicy(name string) {
// spawn new goroutine to avoid heap/stack memory leak when the recover count is big
go s.executeProcessWithRetryPolicy(name)
return
}
@ -162,6 +164,7 @@ func (s *Supervisor) executeProcessWithRetryPolicy(name string) {
slog.Int("attempt", i), slog.String("error", err.Error()))
s.waitFoRetry(name)
continue
}
@ -182,7 +185,7 @@ func (s *Supervisor) executeProcessWithRetryPolicy(name string) {
}
// WaitOnShutdownSignal wait to receive shutdown signal.
// WaitOnShutdownSignal should not be called in other goroutines except main goroutine of application
// WaitOnShutdownSignal should not be called in other goroutines except main goroutine of application.
func (s *Supervisor) WaitOnShutdownSignal() {
// TODO : is it necessary to add os.Interrupt to supervisor config?
signal.Notify(s.shutdownSignal, os.Interrupt)
@ -208,6 +211,7 @@ func (s *Supervisor) gracefulShutdown() {
case <-forceExitCtx.Done():
s.logger.Info("supervisor terminates its job.", slog.Int("number_of_unfinished_processes", len(s.processes)))
return
}
}
@ -226,6 +230,7 @@ func (s *Supervisor) isRecoverable(name string) bool {
v, ok := s.processes[name]
if !ok {
s.logger.Warn("process doesn't exist", slog.String("process_name", name))
return false
}
@ -243,6 +248,7 @@ func (s *Supervisor) isFatal(name string) bool {
v, ok := s.processes[name]
if !ok {
s.logger.Warn("process doesn't exist", slog.String("process_name", name))
return false
}
@ -256,6 +262,7 @@ func (s *Supervisor) incRecover(name string) {
v, ok := s.processes[name]
if !ok {
s.logger.Warn("process doesn't exist", slog.String("process_name", name))
return
}
@ -270,12 +277,14 @@ func (s *Supervisor) retryCount(name string) int {
v, ok := s.processes[name]
if !ok {
s.logger.Warn("process doesn't exist", slog.String("process_name", name))
return -1
}
return v.options.RetryCount
}
//nolint
func (s *Supervisor) retryInterval(name string) time.Duration {
s.lock.Lock()
defer s.lock.Unlock()
@ -283,6 +292,7 @@ func (s *Supervisor) retryInterval(name string) time.Duration {
v, ok := s.processes[name]
if !ok {
s.logger.Warn("process doesn't exist", slog.String("process_name", name))
return -1
}
@ -295,6 +305,7 @@ func (s *Supervisor) waitFoRecover(name string) {
v, ok := s.processes[name]
if !ok {
s.logger.Warn("process doesn't exist", slog.String("process_name", name))
return
}
@ -312,6 +323,7 @@ func (s *Supervisor) waitFoRetry(name string) {
v, ok := s.processes[name]
if !ok {
s.logger.Warn("process doesn't exist", slog.String("process_name", name))
return
}
@ -334,6 +346,7 @@ func (s *Supervisor) handler(name string) ProcessFunc {
v, ok := s.processes[name]
if !ok {
s.logger.Warn("process doesn't exist", slog.String("process_name", name))
return noopProcessFunc
}

2
test/mock/benefactor_kind_box_req_mock.go
View File

@ -8,7 +8,7 @@ import (
"git.gocasts.ir/ebhomengo/niki/entity"
)
const RepoErr = "repository error"
const RepoErr = "record not found"
type DefaultKindBoxReqTest struct {
BenefactorID uint

18
vendor/github.com/asaskevich/govalidator/types.go generated vendored
View File

@ -72,13 +72,13 @@ var ParamTagMap = map[string]ParamValidator{
// ParamTagRegexMap maps param tags to their respective regexes.
var ParamTagRegexMap = map[string]*regexp.Regexp{
"range": regexp.MustCompile("^range\\((\\d+)\\|(\\d+)\\)$"),
"length": regexp.MustCompile("^length\\((\\d+)\\|(\\d+)\\)$"),
"runelength": regexp.MustCompile("^runelength\\((\\d+)\\|(\\d+)\\)$"),
"stringlength": regexp.MustCompile("^stringlength\\((\\d+)\\|(\\d+)\\)$"),
"in": regexp.MustCompile(`^in\((.*)\)`),
"matches": regexp.MustCompile(`^matches\((.+)\)$`),
"rsapub": regexp.MustCompile("^rsapub\\((\\d+)\\)$"),
"range": regexp.MustCompile("^range\\((\\d+)\\|(\\d+)\\)$"),
"length": regexp.MustCompile("^length\\((\\d+)\\|(\\d+)\\)$"),
"runelength": regexp.MustCompile("^runelength\\((\\d+)\\|(\\d+)\\)$"),
"stringlength": regexp.MustCompile("^stringlength\\((\\d+)\\|(\\d+)\\)$"),
"in": regexp.MustCompile(`^in\((.*)\)`),
"matches": regexp.MustCompile(`^matches\((.+)\)$`),
"rsapub": regexp.MustCompile("^rsapub\\((\\d+)\\)$"),
"minstringlength": regexp.MustCompile("^minstringlength\\((\\d+)\\)$"),
"maxstringlength": regexp.MustCompile("^maxstringlength\\((\\d+)\\)$"),
}
@ -173,7 +173,7 @@ type ISO3166Entry struct {
Numeric string
}
//ISO3166List based on https://www.iso.org/obp/ui/#search/code/ Code Type "Officially Assigned Codes"
// ISO3166List based on https://www.iso.org/obp/ui/#search/code/ Code Type "Officially Assigned Codes"
var ISO3166List = []ISO3166Entry{
{"Afghanistan", "Afghanistan (l')", "AF", "AFG", "004"},
{"Albania", "Albanie (l')", "AL", "ALB", "008"},
@ -463,7 +463,7 @@ type ISO693Entry struct {
English string
}
//ISO693List based on http://data.okfn.org/data/core/language-codes/r/language-codes-3b2.json
// ISO693List based on http://data.okfn.org/data/core/language-codes/r/language-codes-3b2.json
var ISO693List = []ISO693Entry{
{Alpha3bCode: "aar", Alpha2Code: "aa", English: "Afar"},
{Alpha3bCode: "abk", Alpha2Code: "ab", English: "Abkhazian"},

33
vendor/github.com/asaskevich/govalidator/validator.go generated vendored
View File

@ -37,25 +37,32 @@ const RF3339WithoutZone = "2006-01-02T15:04:05"
// SetFieldsRequiredByDefault causes validation to fail when struct fields
// do not include validations or are not explicitly marked as exempt (using `valid:"-"` or `valid:"email,optional"`).
// This struct definition will fail govalidator.ValidateStruct() (and the field values do not matter):
// type exampleStruct struct {
// Name string ``
// Email string `valid:"email"`
//
// type exampleStruct struct {
// Name string ``
// Email string `valid:"email"`
//
// This, however, will only fail when Email is empty or an invalid email address:
// type exampleStruct2 struct {
// Name string `valid:"-"`
// Email string `valid:"email"`
//
// type exampleStruct2 struct {
// Name string `valid:"-"`
// Email string `valid:"email"`
//
// Lastly, this will only fail when Email is an invalid email address but not when it's empty:
// type exampleStruct2 struct {
// Name string `valid:"-"`
// Email string `valid:"email,optional"`
//
// type exampleStruct2 struct {
// Name string `valid:"-"`
// Email string `valid:"email,optional"`
func SetFieldsRequiredByDefault(value bool) {
fieldsRequiredByDefault = value
}
// SetNilPtrAllowedByRequired causes validation to pass for nil ptrs when a field is set to required.
// The validation will still reject ptr fields in their zero value state. Example with this enabled:
// type exampleStruct struct {
// Name *string `valid:"required"`
//
// type exampleStruct struct {
// Name *string `valid:"required"`
//
// With `Name` set to "", this will be considered invalid input and will cause a validation error.
// With `Name` set to nil, this will be considered valid by validation.
// By default this is disabled.
@ -154,8 +161,8 @@ func IsAlpha(str string) bool {
return rxAlpha.MatchString(str)
}
//IsUTFLetter check if the string contains only unicode letter characters.
//Similar to IsAlpha but for all languages. Empty string is valid.
// IsUTFLetter check if the string contains only unicode letter characters.
// Similar to IsAlpha but for all languages. Empty string is valid.
func IsUTFLetter(str string) bool {
if IsNull(str) {
return true

0
vendor/github.com/brianvoe/gofakeit/v6/.gitignore generated vendored Normal file
View File

458
vendor/github.com/brianvoe/gofakeit/v6/BENCHMARKS.md generated vendored Normal file
View File

@ -0,0 +1,458 @@
go test -bench=. -benchmem
goos: linux
goarch: amd64
pkg: github.com/brianvoe/gofakeit/v6
cpu: 11th Gen Intel(R) Core(TM) i7-1165G7 @ 2.80GHz
Table generated with tablesgenerator.com/markdown_tables
| Benchmark | Ops | CPU | MEM | MEM alloc |
|--------------------------------------------------|------------|------------------|----------------|-------------------|
| BenchmarkAddress/package-8 | 1270872 | 940.1 ns/op | 197 B/op | 5 allocs/op |
| BenchmarkAddress/Faker_math-8 | 1238563 | 1042 ns/op | 197 B/op | 5 allocs/op |
| BenchmarkAddress/Faker_crypto-8 | 139857 | 7862 ns/op | 197 B/op | 5 allocs/op |
| BenchmarkStreet/package-8 | 2955518 | 422.6 ns/op | 26 B/op | 2 allocs/op |
| BenchmarkStreet/Faker_math-8 | 3027224 | 427.3 ns/op | 26 B/op | 2 allocs/op |
| BenchmarkStreet/Faker_crypto-8 | 352165 | 3559 ns/op | 26 B/op | 2 allocs/op |
| BenchmarkStreetNumber/package-8 | 6842211 | 149.2 ns/op | 4 B/op | 1 allocs/op |
| BenchmarkStreetNumber/Faker_math-8 | 6924288 | 158.8 ns/op | 4 B/op | 1 allocs/op |
| BenchmarkStreetNumber/Faker_crypto-8 | 549988 | 1900 ns/op | 4 B/op | 1 allocs/op |
| BenchmarkStreetPrefix/package-8 | 18441643 | 74.12 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkStreetPrefix/Faker_math-8 | 17888110 | 67.51 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkStreetPrefix/Faker_crypto-8 | 2650390 | 458.9 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkStreetName/package-8 | 18799832 | 62.90 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkStreetName/Faker_math-8 | 16124620 | 63.57 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkStreetName/Faker_crypto-8 | 2873138 | 428.2 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkStreetSuffix/package-8 | 17192164 | 72.19 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkStreetSuffix/Faker_math-8 | 16545355 | 65.44 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkStreetSuffix/Faker_crypto-8 | 2986934 | 450.9 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkCity/package-8 | 18553683 | 64.93 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkCity/Faker_math-8 | 17648109 | 63.77 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkCity/Faker_crypto-8 | 2567427 | 470.8 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkState/package-8 | 18262387 | 66.25 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkState/Faker_math-8 | 16690209 | 73.21 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkState/Faker_crypto-8 | 2599795 | 401.3 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkStateAbr/package-8 | 17492332 | 63.87 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkStateAbr/Faker_math-8 | 18612169 | 64.82 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkStateAbr/Faker_crypto-8 | 2821579 | 460.0 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkZip/package-8 | 7573238 | 157.1 ns/op | 5 B/op | 1 allocs/op |
| BenchmarkZip/Faker_math-8 | 6644562 | 163.4 ns/op | 5 B/op | 1 allocs/op |
| BenchmarkZip/Faker_crypto-8 | 484525 | 2470 ns/op | 5 B/op | 1 allocs/op |
| BenchmarkCountry/package-8 | 15623450 | 65.65 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkCountry/Faker_math-8 | 17786485 | 76.22 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkCountry/Faker_crypto-8 | 3002818 | 400.3 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkCountryAbr/package-8 | 17296935 | 66.75 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkCountryAbr/Faker_math-8 | 17862819 | 67.41 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkCountryAbr/Faker_crypto-8 | 2931120 | 426.0 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkLatitude/package-8 | 46248466 | 26.11 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkLatitude/Faker_math-8 | 46120956 | 26.00 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkLatitude/Faker_crypto-8 | 3512108 | 366.7 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkLongitude/package-8 | 47443129 | 24.03 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkLongitude/Faker_math-8 | 46691144 | 24.64 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkLongitude/Faker_crypto-8 | 3501789 | 365.8 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkLatitudeInRange/package-8 | 44125588 | 26.96 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkLatitudeInRange/Faker_math-8 | 40113348 | 27.36 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkLatitudeInRange/Faker_crypto-8 | 3227358 | 378.4 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkLongitudeInRange/package-8 | 38948743 | 32.36 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkLongitudeInRange/Faker_math-8 | 36491187 | 27.86 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkLongitudeInRange/Faker_crypto-8 | 3004773 | 350.4 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkPetName/package-8 | 23445927 | 60.81 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkPetName/Faker_math-8 | 23982228 | 53.68 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkPetName/Faker_crypto-8 | 2681886 | 458.0 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkAnimal/package-8 | 23230071 | 55.13 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkAnimal/Faker_math-8 | 21923606 | 53.10 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkAnimal/Faker_crypto-8 | 2680177 | 411.6 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkAnimalType/package-8 | 18826995 | 53.45 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkAnimalType/Faker_math-8 | 22170756 | 63.39 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkAnimalType/Faker_crypto-8 | 2780270 | 399.6 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkFarmAnimal/package-8 | 18548028 | 64.87 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkFarmAnimal/Faker_math-8 | 17291526 | 62.47 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkFarmAnimal/Faker_crypto-8 | 2543520 | 409.9 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkCat/package-8 | 21213028 | 68.91 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkCat/Faker_math-8 | 19973062 | 58.74 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkCat/Faker_crypto-8 | 2985601 | 405.2 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkDog/package-8 | 16995627 | 68.15 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkDog/Faker_math-8 | 17296502 | 81.35 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkDog/Faker_crypto-8 | 2530860 | 433.1 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkBird/package-8 | 14445968 | 81.31 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkBird/Faker_math-8 | 14545851 | 82.69 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkBird/Faker_crypto-8 | 2892721 | 420.4 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkAppName/package-8 | 2799828 | 438.6 ns/op | 25 B/op | 1 allocs/op |
| BenchmarkAppName/Faker_math-8 | 2784135 | 431.1 ns/op | 25 B/op | 1 allocs/op |
| BenchmarkAppName/Faker_crypto-8 | 611072 | 1923 ns/op | 25 B/op | 1 allocs/op |
| BenchmarkAppVersion/package-8 | 7552165 | 154.1 ns/op | 7 B/op | 1 allocs/op |
| BenchmarkAppVersion/Faker_math-8 | 8020767 | 156.6 ns/op | 7 B/op | 1 allocs/op |
| BenchmarkAppVersion/Faker_crypto-8 | 875899 | 1209 ns/op | 7 B/op | 1 allocs/op |
| BenchmarkAppAuthor/package-8 | 9596493 | 119.7 ns/op | 8 B/op | 0 allocs/op |
| BenchmarkAppAuthor/Faker_math-8 | 10068729 | 121.0 ns/op | 8 B/op | 0 allocs/op |
| BenchmarkAppAuthor/Faker_crypto-8 | 1212542 | 983.7 ns/op | 8 B/op | 0 allocs/op |
| BenchmarkUsername/package-8 | 6687600 | 174.6 ns/op | 16 B/op | 2 allocs/op |
| BenchmarkUsername/Faker_math-8 | 7233685 | 173.3 ns/op | 16 B/op | 2 allocs/op |
| BenchmarkUsername/Faker_crypto-8 | 616884 | 2166 ns/op | 16 B/op | 2 allocs/op |
| BenchmarkPassword/package-8 | 2966407 | 401.0 ns/op | 336 B/op | 6 allocs/op |
| BenchmarkPassword/Faker_math-8 | 3080845 | 399.8 ns/op | 336 B/op | 6 allocs/op |
| BenchmarkPassword/Faker_crypto-8 | 182074 | 5963 ns/op | 336 B/op | 6 allocs/op |
| BenchmarkBeerName/package-8 | 23768442 | 53.26 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkBeerName/Faker_math-8 | 22010898 | 63.87 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkBeerName/Faker_crypto-8 | 2569424 | 392.6 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkBeerStyle/package-8 | 17567354 | 69.64 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkBeerStyle/Faker_math-8 | 16695721 | 80.73 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkBeerStyle/Faker_crypto-8 | 2710214 | 407.6 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkBeerHop/package-8 | 20877854 | 56.43 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkBeerHop/Faker_math-8 | 22603234 | 65.04 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkBeerHop/Faker_crypto-8 | 2618493 | 419.3 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkBeerYeast/package-8 | 20738073 | 67.89 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkBeerYeast/Faker_math-8 | 21325231 | 67.34 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkBeerYeast/Faker_crypto-8 | 3042529 | 399.8 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkBeerMalt/package-8 | 15756969 | 65.67 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkBeerMalt/Faker_math-8 | 18026910 | 71.42 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkBeerMalt/Faker_crypto-8 | 2949741 | 429.4 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkBeerIbu/package-8 | 32683443 | 35.57 ns/op | 8 B/op | 1 allocs/op |
| BenchmarkBeerIbu/Faker_math-8 | 29983339 | 36.03 ns/op | 8 B/op | 1 allocs/op |
| BenchmarkBeerIbu/Faker_crypto-8 | 3094896 | 386.6 ns/op | 8 B/op | 1 allocs/op |
| BenchmarkBeerAlcohol/package-8 | 4744302 | 243.6 ns/op | 32 B/op | 3 allocs/op |
| BenchmarkBeerAlcohol/Faker_math-8 | 4718923 | 252.0 ns/op | 32 B/op | 3 allocs/op |
| BenchmarkBeerAlcohol/Faker_crypto-8 | 1952740 | 656.0 ns/op | 32 B/op | 3 allocs/op |
| BenchmarkBeerBlg/package-8 | 4086861 | 270.6 ns/op | 40 B/op | 3 allocs/op |
| BenchmarkBeerBlg/Faker_math-8 | 4488897 | 259.5 ns/op | 40 B/op | 3 allocs/op |
| BenchmarkBeerBlg/Faker_crypto-8 | 1865367 | 646.7 ns/op | 40 B/op | 3 allocs/op |
| BenchmarkCar/package-8 | 2800782 | 400.5 ns/op | 96 B/op | 1 allocs/op |
| BenchmarkCar/Faker_math-8 | 2938509 | 396.5 ns/op | 96 B/op | 1 allocs/op |
| BenchmarkCar/Faker_crypto-8 | 461906 | 2590 ns/op | 96 B/op | 1 allocs/op |
| BenchmarkCarType/package-8 | 23655384 | 51.72 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkCarType/Faker_math-8 | 25902462 | 50.55 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkCarType/Faker_crypto-8 | 3035287 | 455.8 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkCarFuelType/package-8 | 18750069 | 63.80 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkCarFuelType/Faker_math-8 | 18858705 | 63.15 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkCarFuelType/Faker_crypto-8 | 3028026 | 387.0 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkCarTransmissionType/package-8 | 22570701 | 54.01 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkCarTransmissionType/Faker_math-8 | 21484246 | 64.27 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkCarTransmissionType/Faker_crypto-8 | 3061364 | 387.6 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkCarMaker/package-8 | 17628445 | 68.23 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkCarMaker/Faker_math-8 | 21573310 | 64.19 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkCarMaker/Faker_crypto-8 | 2688284 | 475.5 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkCarModel/package-8 | 18500498 | 73.43 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkCarModel/Faker_math-8 | 16116993 | 66.91 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkCarModel/Faker_crypto-8 | 2487638 | 440.0 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkCelebrityActor/package-8 | 18712833 | 74.12 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkCelebrityActor/Faker_math-8 | 18564168 | 68.96 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkCelebrityActor/Faker_crypto-8 | 2593150 | 415.5 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkCelebrityBusiness/package-8 | 18721152 | 68.98 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkCelebrityBusiness/Faker_math-8 | 16916186 | 70.66 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkCelebrityBusiness/Faker_crypto-8 | 2578786 | 407.7 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkCelebritySport/package-8 | 16716724 | 87.51 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkCelebritySport/Faker_math-8 | 16602294 | 86.41 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkCelebritySport/Faker_crypto-8 | 2919696 | 419.0 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkColor/package-8 | 17871778 | 62.28 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkColor/Faker_math-8 | 21601353 | 62.63 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkColor/Faker_crypto-8 | 3040459 | 463.1 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkNiceColors/package-8 | 81438092 | 14.86 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkNiceColors/Faker_math-8 | 75775309 | 18.52 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkNiceColors/Faker_crypto-8 | 3450939 | 353.9 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkSafeColor/package-8 | 22775230 | 53.52 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkSafeColor/Faker_math-8 | 24526308 | 59.40 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkSafeColor/Faker_crypto-8 | 3103851 | 413.3 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkHexColor/package-8 | 4640522 | 255.2 ns/op | 24 B/op | 3 allocs/op |
| BenchmarkHexColor/Faker_math-8 | 4723542 | 257.2 ns/op | 24 B/op | 3 allocs/op |
| BenchmarkHexColor/Faker_crypto-8 | 283828 | 4447 ns/op | 24 B/op | 3 allocs/op |
| BenchmarkRGBColor/package-8 | 19721971 | 59.64 ns/op | 24 B/op | 1 allocs/op |
| BenchmarkRGBColor/Faker_math-8 | 18808492 | 67.35 ns/op | 24 B/op | 1 allocs/op |
| BenchmarkRGBColor/Faker_crypto-8 | 1000000 | 1066 ns/op | 24 B/op | 1 allocs/op |
| BenchmarkCompany/package-8 | 22072651 | 48.06 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkCompany/Faker_math-8 | 22528284 | 53.94 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkCompany/Faker_crypto-8 | 2690668 | 402.4 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkCompanySuffix/package-8 | 28169413 | 48.00 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkCompanySuffix/Faker_math-8 | 20685153 | 52.20 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkCompanySuffix/Faker_crypto-8 | 3018765 | 418.0 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkBuzzWord/package-8 | 24238677 | 54.55 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkBuzzWord/Faker_math-8 | 22195419 | 52.30 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkBuzzWord/Faker_crypto-8 | 2840428 | 392.1 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkBS/package-8 | 23481436 | 56.33 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkBS/Faker_math-8 | 23195737 | 65.66 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkBS/Faker_crypto-8 | 3027972 | 419.8 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkJob/package-8 | 4432520 | 253.5 ns/op | 64 B/op | 1 allocs/op |
| BenchmarkJob/Faker_math-8 | 4513154 | 253.7 ns/op | 64 B/op | 1 allocs/op |
| BenchmarkJob/Faker_crypto-8 | 686028 | 1716 ns/op | 64 B/op | 1 allocs/op |
| BenchmarkJobTitle/package-8 | 20079558 | 54.21 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkJobTitle/Faker_math-8 | 21871627 | 54.86 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkJobTitle/Faker_crypto-8 | 3017896 | 413.3 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkJobDescriptor/package-8 | 21579855 | 53.36 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkJobDescriptor/Faker_math-8 | 24638751 | 55.91 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkJobDescriptor/Faker_crypto-8 | 2984810 | 415.9 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkJobLevel/package-8 | 18311070 | 59.35 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkJobLevel/Faker_math-8 | 17051210 | 59.53 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkJobLevel/Faker_crypto-8 | 2991106 | 426.8 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkCSVLookup100-8 | 1468 | 780852 ns/op | 437416 B/op | 5933 allocs/op |
| BenchmarkCSVLookup1000-8 | 151 | 7853471 ns/op | 4224820 B/op | 59612 allocs/op |
| BenchmarkCSVLookup10000-8 | 14 | 78165009 ns/op | 41208010 B/op | 597842 allocs/op |
| BenchmarkCSVLookup100000-8 | 2 | 768800840 ns/op | 437275164 B/op | 5980461 allocs/op |
| BenchmarkEmoji/package-8 | 22212386 | 54.40 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkEmoji/Faker_math-8 | 21471013 | 51.55 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkEmoji/Faker_crypto-8 | 3036081 | 458.1 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkEmojiDescription/package-8 | 18250413 | 57.08 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkEmojiDescription/Faker_math-8 | 21924381 | 57.58 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkEmojiDescription/Faker_crypto-8 | 2837050 | 387.5 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkEmojiCategory/package-8 | 21270252 | 55.87 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkEmojiCategory/Faker_math-8 | 21421813 | 59.59 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkEmojiCategory/Faker_crypto-8 | 2635878 | 491.0 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkEmojiAlias/package-8 | 18760875 | 68.20 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkEmojiAlias/Faker_math-8 | 16918242 | 67.60 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkEmojiAlias/Faker_crypto-8 | 2854717 | 488.9 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkEmojiTag/package-8 | 19953885 | 65.43 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkEmojiTag/Faker_math-8 | 18220396 | 72.91 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkEmojiTag/Faker_crypto-8 | 2802847 | 426.2 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkError/package-8 | 1547610 | 786.6 ns/op | 279 B/op | 8 allocs/op |
| BenchmarkError/Faker_math-8 | 1504578 | 794.1 ns/op | 279 B/op | 8 allocs/op |
| BenchmarkError/Faker_crypto-8 | 800712 | 1476 ns/op | 279 B/op | 8 allocs/op |
| BenchmarkErrorObject/package-8 | 6054552 | 190.3 ns/op | 32 B/op | 3 allocs/op |
| BenchmarkErrorObject/Faker_math-8 | 5968180 | 190.3 ns/op | 32 B/op | 3 allocs/op |
| BenchmarkErrorObject/Faker_crypto-8 | 2088008 | 618.0 ns/op | 32 B/op | 3 allocs/op |
| BenchmarkErrorDatabase/package-8 | 5275713 | 212.8 ns/op | 64 B/op | 3 allocs/op |
| BenchmarkErrorDatabase/Faker_math-8 | 5407803 | 217.3 ns/op | 64 B/op | 3 allocs/op |
| BenchmarkErrorDatabase/Faker_crypto-8 | 2005333 | 628.7 ns/op | 63 B/op | 3 allocs/op |
| BenchmarkErrorGRPC/package-8 | 5700810 | 202.9 ns/op | 64 B/op | 3 allocs/op |
| BenchmarkErrorGRPC/Faker_math-8 | 5907589 | 202.5 ns/op | 64 B/op | 3 allocs/op |
| BenchmarkErrorGRPC/Faker_crypto-8 | 2027650 | 643.3 ns/op | 64 B/op | 3 allocs/op |
| BenchmarkErrorHTTP/package-8 | 3182026 | 321.6 ns/op | 157 B/op | 4 allocs/op |
| BenchmarkErrorHTTP/Faker_math-8 | 3667356 | 314.9 ns/op | 157 B/op | 4 allocs/op |
| BenchmarkErrorHTTP/Faker_crypto-8 | 1590696 | 720.2 ns/op | 157 B/op | 4 allocs/op |
| BenchmarkErrorHTTPClient/package-8 | 5745494 | 204.0 ns/op | 52 B/op | 3 allocs/op |
| BenchmarkErrorHTTPClient/Faker_math-8 | 5549187 | 212.8 ns/op | 52 B/op | 3 allocs/op |
| BenchmarkErrorHTTPClient/Faker_crypto-8 | 2011905 | 596.7 ns/op | 52 B/op | 3 allocs/op |
| BenchmarkErrorHTTPServer/package-8 | 5466012 | 214.7 ns/op | 59 B/op | 3 allocs/op |
| BenchmarkErrorHTTPServer/Faker_math-8 | 5542838 | 207.3 ns/op | 59 B/op | 3 allocs/op |
| BenchmarkErrorHTTPServer/Faker_crypto-8 | 1939080 | 633.9 ns/op | 59 B/op | 3 allocs/op |
| BenchmarkErrorRuntime/package-8 | 4245986 | 263.4 ns/op | 150 B/op | 3 allocs/op |
| BenchmarkErrorRuntime/Faker_math-8 | 4355534 | 263.1 ns/op | 150 B/op | 3 allocs/op |
| BenchmarkErrorRuntime/Faker_crypto-8 | 1782044 | 651.4 ns/op | 150 B/op | 3 allocs/op |
| BenchmarkErrorValidation/package-8 | 1659858 | 715.7 ns/op | 268 B/op | 7 allocs/op |
| BenchmarkErrorValidation/Faker_math-8 | 1690849 | 716.4 ns/op | 268 B/op | 7 allocs/op |
| BenchmarkErrorValidation/Faker_crypto-8 | 883600 | 1348 ns/op | 268 B/op | 7 allocs/op |
| BenchmarkFileMimeType/package-8 | 18005230 | 56.88 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkFileMimeType/Faker_math-8 | 21229381 | 54.62 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkFileMimeType/Faker_crypto-8 | 2605701 | 462.5 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkFileExtension/package-8 | 19272264 | 73.07 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkFileExtension/Faker_math-8 | 20149288 | 60.79 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkFileExtension/Faker_crypto-8 | 2627210 | 423.1 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkCusip/package-8 | 5402995 | 224.9 ns/op | 24 B/op | 2 allocs/op |
| BenchmarkCusip/Faker_math-8 | 5367218 | 221.1 ns/op | 24 B/op | 2 allocs/op |
| BenchmarkCusip/Faker_crypto-8 | 363460 | 2967 ns/op | 24 B/op | 2 allocs/op |
| BenchmarkIsin/package-8 | 1742368 | 701.4 ns/op | 533 B/op | 8 allocs/op |
| BenchmarkIsin/Faker_math-8 | 1653408 | 715.5 ns/op | 533 B/op | 8 allocs/op |
| BenchmarkIsin/Faker_crypto-8 | 330396 | 3583 ns/op | 533 B/op | 8 allocs/op |
| BenchmarkFruit/package-8 | 21421066 | 55.23 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkFruit/Faker_math-8 | 22680361 | 55.68 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkFruit/Faker_crypto-8 | 2914611 | 486.7 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkVegetable/package-8 | 21113413 | 56.44 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkVegetable/Faker_math-8 | 21101716 | 60.98 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkVegetable/Faker_crypto-8 | 2811384 | 467.1 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkBreakfast/package-8 | 8954784 | 127.7 ns/op | 32 B/op | 1 allocs/op |
| BenchmarkBreakfast/Faker_math-8 | 9430814 | 128.8 ns/op | 32 B/op | 1 allocs/op |
| BenchmarkBreakfast/Faker_crypto-8 | 2132481 | 496.5 ns/op | 32 B/op | 1 allocs/op |
| BenchmarkLunch/package-8 | 8934501 | 125.9 ns/op | 34 B/op | 1 allocs/op |
| BenchmarkLunch/Faker_math-8 | 8668546 | 128.9 ns/op | 34 B/op | 1 allocs/op |
| BenchmarkLunch/Faker_crypto-8 | 2216348 | 518.3 ns/op | 34 B/op | 1 allocs/op |
| BenchmarkDinner/package-8 | 9317936 | 125.2 ns/op | 36 B/op | 1 allocs/op |
| BenchmarkDinner/Faker_math-8 | 9023473 | 126.3 ns/op | 36 B/op | 1 allocs/op |
| BenchmarkDinner/Faker_crypto-8 | 2435984 | 518.9 ns/op | 36 B/op | 1 allocs/op |
| BenchmarkDrink/package-8 | 7698025 | 143.4 ns/op | 7 B/op | 2 allocs/op |
| BenchmarkDrink/Faker_math-8 | 8096294 | 139.8 ns/op | 7 B/op | 2 allocs/op |
| BenchmarkDrink/Faker_crypto-8 | 2247427 | 536.2 ns/op | 7 B/op | 2 allocs/op |
| BenchmarkSnack/package-8 | 8109601 | 149.2 ns/op | 32 B/op | 1 allocs/op |
| BenchmarkSnack/Faker_math-8 | 7993006 | 150.5 ns/op | 32 B/op | 1 allocs/op |
| BenchmarkSnack/Faker_crypto-8 | 2214736 | 535.7 ns/op | 32 B/op | 1 allocs/op |
| BenchmarkDessert/package-8 | 8295364 | 133.9 ns/op | 31 B/op | 2 allocs/op |
| BenchmarkDessert/Faker_math-8 | 8610325 | 134.1 ns/op | 31 B/op | 2 allocs/op |
| BenchmarkDessert/Faker_crypto-8 | 2205777 | 507.4 ns/op | 31 B/op | 2 allocs/op |
| BenchmarkGamertag/package-8 | 2111506 | 544.8 ns/op | 83 B/op | 5 allocs/op |
| BenchmarkGamertag/Faker_math-8 | 2203573 | 551.4 ns/op | 83 B/op | 5 allocs/op |
| BenchmarkGamertag/Faker_crypto-8 | 487366 | 2428 ns/op | 83 B/op | 5 allocs/op |
| BenchmarkDice/package-8 | 43259642 | 26.58 ns/op | 8 B/op | 1 allocs/op |
| BenchmarkDice/Faker_math-8 | 42908084 | 26.84 ns/op | 8 B/op | 1 allocs/op |
| BenchmarkDice/Faker_crypto-8 | 2953483 | 395.5 ns/op | 8 B/op | 1 allocs/op |
| BenchmarkGenerate/package-8 | 383122 | 2767 ns/op | 1139 B/op | 29 allocs/op |
| BenchmarkGenerate/Complex-8 | 135508 | 8555 ns/op | 4440 B/op | 80 allocs/op |
| BenchmarkGenerate/Faker_math-8 | 377151 | 2817 ns/op | 1139 B/op | 29 allocs/op |
| BenchmarkGenerate/Faker_crypto-8 | 152226 | 7234 ns/op | 1139 B/op | 29 allocs/op |
| BenchmarkRegex/package-8 | 628683 | 1922 ns/op | 1632 B/op | 27 allocs/op |
| BenchmarkRegex/Faker_math-8 | 591548 | 1940 ns/op | 1632 B/op | 27 allocs/op |
| BenchmarkRegex/Faker_crypto-8 | 616701 | 1934 ns/op | 1632 B/op | 27 allocs/op |
| BenchmarkRegexEmail/package-8 | 174812 | 6607 ns/op | 4084 B/op | 90 allocs/op |
| BenchmarkRegexEmail/Faker_math-8 | 174512 | 6619 ns/op | 4084 B/op | 90 allocs/op |
| BenchmarkRegexEmail/Faker_crypto-8 | 62312 | 18793 ns/op | 4083 B/op | 90 allocs/op |
| BenchmarkMap/package-8 | 318559 | 3275 ns/op | 1113 B/op | 16 allocs/op |
| BenchmarkMap/Faker_math-8 | 315990 | 3319 ns/op | 1113 B/op | 16 allocs/op |
| BenchmarkMap/Faker_crypto-8 | 46202 | 23997 ns/op | 1115 B/op | 16 allocs/op |
| BenchmarkHackerPhrase/package-8 | 155998 | 7191 ns/op | 3004 B/op | 50 allocs/op |
| BenchmarkHackerPhrase/Faker_math-8 | 154675 | 7305 ns/op | 3008 B/op | 50 allocs/op |
| BenchmarkHackerPhrase/Faker_crypto-8 | 109282 | 10268 ns/op | 3007 B/op | 50 allocs/op |
| BenchmarkHackerAbbreviation/package-8 | 21881574 | 57.57 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkHackerAbbreviation/Faker_math-8 | 18534495 | 59.55 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkHackerAbbreviation/Faker_crypto-8 | 2607735 | 401.6 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkHackerAdjective/package-8 | 24286845 | 55.74 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkHackerAdjective/Faker_math-8 | 22684101 | 55.22 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkHackerAdjective/Faker_crypto-8 | 2953530 | 490.5 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkHackerNoun/package-8 | 22554241 | 55.35 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkHackerNoun/Faker_math-8 | 18360708 | 56.78 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkHackerNoun/Faker_crypto-8 | 2823256 | 464.8 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkHackerVerb/package-8 | 19236123 | 65.49 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkHackerVerb/Faker_math-8 | 18090754 | 68.18 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkHackerVerb/Faker_crypto-8 | 2880181 | 439.2 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkHackeringVerb/package-8 | 19090326 | 71.74 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkHackeringVerb/Faker_math-8 | 19048659 | 63.31 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkHackeringVerb/Faker_crypto-8 | 3020748 | 404.5 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkReplaceWithNumbers-8 | 162931 | 7098 ns/op | 32 B/op | 2 allocs/op |
| BenchmarkHipsterWord/package-8 | 24059244 | 54.69 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkHipsterWord/Faker_math-8 | 21708511 | 52.98 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkHipsterWord/Faker_crypto-8 | 2870858 | 396.1 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkHipsterSentence/package-8 | 1278764 | 927.7 ns/op | 288 B/op | 3 allocs/op |
| BenchmarkHipsterSentence/Faker_math-8 | 1287939 | 955.0 ns/op | 288 B/op | 3 allocs/op |
| BenchmarkHipsterSentence/Faker_crypto-8 | 237703 | 4595 ns/op | 288 B/op | 3 allocs/op |
| BenchmarkHipsterParagraph/package-8 | 57895 | 18466 ns/op | 10521 B/op | 48 allocs/op |
| BenchmarkHipsterParagraph/Faker_math-8 | 61772 | 19188 ns/op | 10520 B/op | 48 allocs/op |
| BenchmarkHipsterParagraph/Faker_crypto-8 | 12978 | 91733 ns/op | 10522 B/op | 48 allocs/op |
| BenchmarkInputName/package-8 | 15728428 | 74.49 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkInputName/Faker_math-8 | 13243030 | 89.75 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkInputName/Faker_crypto-8 | 2736225 | 478.4 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkSvg/package-8 | 172828 | 7906 ns/op | 8871 B/op | 52 allocs/op |
| BenchmarkSvg/Faker_math-8 | 161821 | 6754 ns/op | 8875 B/op | 52 allocs/op |
| BenchmarkSvg/Faker_crypto-8 | 29023 | 40910 ns/op | 8862 B/op | 52 allocs/op |
| BenchmarkImageURL/package-8 | 11692422 | 94.34 ns/op | 38 B/op | 3 allocs/op |
| BenchmarkImageURL/Faker_math-8 | 11451087 | 91.39 ns/op | 38 B/op | 3 allocs/op |
| BenchmarkImageURL/Faker_crypto-8 | 12107578 | 92.30 ns/op | 38 B/op | 3 allocs/op |
| BenchmarkImage/package-8 | 50 | 20495942 ns/op | 2457673 B/op | 307202 allocs/op |
| BenchmarkImage/Faker_math-8 | 51 | 20349126 ns/op | 2457780 B/op | 307202 allocs/op |
| BenchmarkImage/Faker_crypto-8 | 3 | 393591549 ns/op | 2457685 B/op | 307202 allocs/op |
| BenchmarkImageJpeg/package-8 | 31 | 32857846 ns/op | 2982318 B/op | 307214 allocs/op |
| BenchmarkImageJpeg/Faker_math-8 | 34 | 31873165 ns/op | 2982479 B/op | 307214 allocs/op |
| BenchmarkImageJpeg/Faker_crypto-8 | 3 | 387670345 ns/op | 2982357 B/op | 307215 allocs/op |
| BenchmarkImagePng/package-8 | 16 | 65425256 ns/op | 5899024 B/op | 307270 allocs/op |
| BenchmarkImagePng/Faker_math-8 | 18 | 67804235 ns/op | 5899314 B/op | 307270 allocs/op |
| BenchmarkImagePng/Faker_crypto-8 | 3 | 396378778 ns/op | 5899005 B/op | 307270 allocs/op |
| BenchmarkDomainName/package-8 | 2344912 | 505.6 ns/op | 95 B/op | 5 allocs/op |
| BenchmarkDomainName/Faker_math-8 | 2265744 | 512.5 ns/op | 95 B/op | 5 allocs/op |
| BenchmarkDomainName/Faker_crypto-8 | 639775 | 1788 ns/op | 95 B/op | 5 allocs/op |
| BenchmarkDomainSuffix/package-8 | 19431498 | 59.95 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkDomainSuffix/Faker_math-8 | 20097267 | 59.04 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkDomainSuffix/Faker_crypto-8 | 2498906 | 437.0 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkURL/package-8 | 1000000 | 1155 ns/op | 277 B/op | 10 allocs/op |
| BenchmarkURL/Faker_math-8 | 1000000 | 1165 ns/op | 277 B/op | 10 allocs/op |
| BenchmarkURL/Faker_crypto-8 | 275793 | 4371 ns/op | 276 B/op | 10 allocs/op |
| BenchmarkHTTPMethod/package-8 | 17651594 | 59.20 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkHTTPMethod/Faker_math-8 | 20081227 | 61.28 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkHTTPMethod/Faker_crypto-8 | 2844322 | 460.1 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkIPv4Address/package-8 | 5215255 | 229.2 ns/op | 16 B/op | 1 allocs/op |
| BenchmarkIPv4Address/Faker_math-8 | 4852905 | 224.9 ns/op | 16 B/op | 1 allocs/op |
| BenchmarkIPv4Address/Faker_crypto-8 | 670951 | 1827 ns/op | 16 B/op | 1 allocs/op |
| BenchmarkIPv6Address/package-8 | 2312482 | 510.0 ns/op | 111 B/op | 8 allocs/op |
| BenchmarkIPv6Address/Faker_math-8 | 2261472 | 521.2 ns/op | 111 B/op | 8 allocs/op |
| BenchmarkIPv6Address/Faker_crypto-8 | 338601 | 3623 ns/op | 111 B/op | 8 allocs/op |
| BenchmarkMacAddress/package-8 | 2809762 | 426.2 ns/op | 24 B/op | 1 allocs/op |
| BenchmarkMacAddress/Faker_math-8 | 2863842 | 425.5 ns/op | 24 B/op | 1 allocs/op |
| BenchmarkMacAddress/Faker_crypto-8 | 376604 | 2688 ns/op | 24 B/op | 1 allocs/op |
| BenchmarkHTTPStatusCode/package-8 | 13488582 | 88.27 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkHTTPStatusCode/Faker_math-8 | 14188726 | 73.23 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkHTTPStatusCode/Faker_crypto-8 | 2497014 | 463.7 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkHTTPStatusCodeSimple/package-8 | 17822486 | 81.54 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkHTTPStatusCodeSimple/Faker_math-8 | 16282341 | 70.72 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkHTTPStatusCodeSimple/Faker_crypto-8 | 2360576 | 451.7 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkLogLevel/package-8 | 19343472 | 67.40 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkLogLevel/Faker_math-8 | 19445798 | 61.84 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkLogLevel/Faker_crypto-8 | 2296162 | 468.5 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkUserAgent/package-8 | 1503814 | 813.9 ns/op | 297 B/op | 5 allocs/op |
| BenchmarkUserAgent/Faker_math-8 | 1462177 | 803.6 ns/op | 298 B/op | 5 allocs/op |
| BenchmarkUserAgent/Faker_crypto-8 | 181178 | 6157 ns/op | 298 B/op | 5 allocs/op |
| BenchmarkChromeUserAgent/package-8 | 1911201 | 596.8 ns/op | 184 B/op | 5 allocs/op |
| BenchmarkChromeUserAgent/Faker_math-8 | 1969712 | 598.1 ns/op | 184 B/op | 5 allocs/op |
| BenchmarkChromeUserAgent/Faker_crypto-8 | 264816 | 4433 ns/op | 184 B/op | 5 allocs/op |
| BenchmarkFirefoxUserAgent/package-8 | 1000000 | 1043 ns/op | 362 B/op | 6 allocs/op |
| BenchmarkFirefoxUserAgent/Faker_math-8 | 1000000 | 1054 ns/op | 362 B/op | 6 allocs/op |
| BenchmarkFirefoxUserAgent/Faker_crypto-8 | 166128 | 7646 ns/op | 362 B/op | 6 allocs/op |
| BenchmarkSafariUserAgent/package-8 | 1000000 | 1022 ns/op | 551 B/op | 7 allocs/op |
| BenchmarkSafariUserAgent/Faker_math-8 | 1000000 | 1017 ns/op | 551 B/op | 7 allocs/op |
| BenchmarkSafariUserAgent/Faker_crypto-8 | 146463 | 7525 ns/op | 551 B/op | 7 allocs/op |
| BenchmarkOperaUserAgent/package-8 | 1844185 | 643.8 ns/op | 212 B/op | 5 allocs/op |
| BenchmarkOperaUserAgent/Faker_math-8 | 1805168 | 654.3 ns/op | 212 B/op | 5 allocs/op |
| BenchmarkOperaUserAgent/Faker_crypto-8 | 219927 | 5257 ns/op | 212 B/op | 5 allocs/op |
| BenchmarkJSONLookup100-8 | 894 | 1194698 ns/op | 537673 B/op | 8141 allocs/op |
| BenchmarkJSONLookup1000-8 | 91 | 12099728 ns/op | 5616708 B/op | 81606 allocs/op |
| BenchmarkJSONLookup10000-8 | 8 | 128144166 ns/op | 62638763 B/op | 817708 allocs/op |
| BenchmarkJSONLookup100000-8 | 1 | 1324756016 ns/op | 616116744 B/op | 8179136 allocs/op |
| BenchmarkLanguage/package-8 | 20946056 | 68.53 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkLanguage/Faker_math-8 | 16884613 | 61.06 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkLanguage/Faker_crypto-8 | 2889944 | 442.0 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkLanguageAbbreviation/package-8 | 20782443 | 53.79 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkLanguageAbbreviation/Faker_math-8 | 17936367 | 56.26 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkLanguageAbbreviation/Faker_crypto-8 | 2630406 | 423.8 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkLanguageBCP/package-8 | 19858063 | 59.00 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkLanguageBCP/Faker_math-8 | 20712447 | 60.02 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkLanguageBCP/Faker_crypto-8 | 2654044 | 469.2 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkProgrammingLanguage/package-8 | 17849598 | 58.34 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkProgrammingLanguage/Faker_math-8 | 20090289 | 70.59 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkProgrammingLanguage/Faker_crypto-8 | 2628798 | 424.4 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkProgrammingLanguageBest/package-8 | 1000000000 | 0.4044 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkProgrammingLanguageBest/Faker_math-8 | 1000000000 | 0.2975 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkProgrammingLanguageBest/Faker_crypto-8 | 1000000000 | 0.2543 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkLoremIpsumWord-8 | 22434632 | 54.96 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkLoremIpsumSentence-8 | 1000000 | 1038 ns/op | 219 B/op | 2 allocs/op |
| BenchmarkLoremIpsumParagraph-8 | 59320 | 19442 ns/op | 8479 B/op | 40 allocs/op |
| BenchmarkMinecraftOre/package-8 | 14624242 | 90.01 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkMinecraftOre/Faker_math-8 | 16379578 | 86.91 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkMinecraftOre/Faker_crypto-8 | 2757652 | 477.0 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkMinecraftWood/package-8 | 15815132 | 83.23 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkMinecraftWood/Faker_math-8 | 14872902 | 75.36 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkMinecraftWood/Faker_crypto-8 | 2524514 | 514.4 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkMinecraftArmorTier/package-8 | 15296107 | 78.58 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkMinecraftArmorTier/Faker_math-8 | 14341870 | 86.33 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkMinecraftArmorTier/Faker_crypto-8 | 2344278 | 473.1 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkMinecraftArmorPart/package-8 | 16863422 | 82.04 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkMinecraftArmorPart/Faker_math-8 | 14052031 | 76.92 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkMinecraftArmorPart/Faker_crypto-8 | 2770314 | 474.5 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkMinecraftWeapon/package-8 | 15759004 | 77.42 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkMinecraftWeapon/Faker_math-8 | 15945940 | 81.48 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkMinecraftWeapon/Faker_crypto-8 | 2254436 | 464.5 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkMinecraftTool/package-8 | 15887787 | 76.39 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkMinecraftTool/Faker_math-8 | 14269508 | 91.01 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkMinecraftTool/Faker_crypto-8 | 2718507 | 525.7 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkMinecraftDye/package-8 | 16131942 | 71.06 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkMinecraftDye/Faker_math-8 | 16802478 | 73.40 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkMinecraftDye/Faker_crypto-8 | 2584966 | 476.4 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkMinecraftFood/package-8 | 14680048 | 87.15 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkMinecraftFood/Faker_math-8 | 13558227 | 86.71 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkMinecraftFood/Faker_crypto-8 | 2329946 | 435.6 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkMinecraftAnimal/package-8 | 15871832 | 85.92 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkMinecraftAnimal/Faker_math-8 | 12411510 | 83.88 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkMinecraftAnimal/Faker_crypto-8 | 2528960 | 441.9 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkMinecraftVillagerJob/package-8 | 13549438 | 80.41 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkMinecraftVillagerJob/Faker_math-8 | 13769702 | 104.5 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkMinecraftVillagerJob/Faker_crypto-8 | 2397300 | 452.2 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkMinecraftVillagerStation/package-8 | 15069139 | 93.65 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkMinecraftVillagerStation/Faker_math-8 | 15468883 | 82.27 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkMinecraftVillagerStation/Faker_crypto-8 | 2469778 | 453.9 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkMinecraftVillagerLevel/package-8 | 13468396 | 102.1 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkMinecraftVillagerLevel/Faker_math-8 | 14354506 | 92.55 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkMinecraftVillagerLevel/Faker_crypto-8 | 2416441 | 544.5 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkMinecraftMobPassive/package-8 | 13299806 | 84.84 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkMinecraftMobPassive/Faker_math-8 | 14181126 | 87.18 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkMinecraftMobPassive/Faker_crypto-8 | 2539264 | 510.0 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkMinecraftMobNeutral/package-8 | 11043175 | 110.7 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkMinecraftMobNeutral/Faker_math-8 | 13059249 | 99.36 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkMinecraftMobNeutral/Faker_crypto-8 | 2394342 | 544.6 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkMinecraftMobHostile/package-8 | 13963809 | 95.66 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkMinecraftMobHostile/Faker_math-8 | 15182318 | 96.90 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkMinecraftMobHostile/Faker_crypto-8 | 2204600 | 538.3 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkMinecraftMobBoss/package-8 | 12737437 | 89.68 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkMinecraftMobBoss/Faker_math-8 | 13494093 | 90.65 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkMinecraftMobBoss/Faker_crypto-8 | 2671172 | 461.3 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkMinecraftBiome/package-8 | 13233918 | 81.47 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkMinecraftBiome/Faker_math-8 | 16109408 | 85.68 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkMinecraftBiome/Faker_crypto-8 | 2205704 | 499.4 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkMinecraftWeather/package-8 | 13371518 | 79.93 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkMinecraftWeather/Faker_math-8 | 14987182 | 80.69 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkMinecraftWeather/Faker_crypto-8 | 2373735 | 473.6 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkBool/package-8 | 75772935 | 15.03 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkBool/Faker_math-8 | 76893664 | 19.04 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkBool/Faker_crypto-8 | 3141634 | 376.4 ns/op | 0 B/op | 0 allocs/op |
| BenchmarkUUID/package-8 | 9382911 | 115.3 ns/op | 64 B/op | 2 allocs/op |
| BenchmarkUUID/Faker_math-8 | 9492183 | 114.1 ns/op | 64 B/op | 2 allocs/op |
| BenchmarkUUID/Faker_crypto-8 | 1000000 | 1039 ns/op | 64 B/op | 2 allocs/op |
| BenchmarkShuffleAnySlice/package-8 | 2234314 | 511.5 ns/op | 24 B/op | 1 allocs/op |

46
vendor/github.com/brianvoe/gofakeit/v6/CODE_OF_CONDUCT.md generated vendored Normal file
View File

@ -0,0 +1,46 @@
# Contributor Covenant Code of Conduct
## Our Pledge
In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.
## Our Standards
Examples of behavior that contributes to creating a positive environment include:
* Using welcoming and inclusive language
* Being respectful of differing viewpoints and experiences
* Gracefully accepting constructive criticism
* Focusing on what is best for the community
* Showing empathy towards other community members
Examples of unacceptable behavior by participants include:
* The use of sexualized language or imagery and unwelcome sexual attention or advances
* Trolling, insulting/derogatory comments, and personal or political attacks
* Public or private harassment
* Publishing others' private information, such as a physical or electronic address, without explicit permission
* Other conduct which could reasonably be considered inappropriate in a professional setting
## Our Responsibilities
Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
## Scope
This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.
## Enforcement
Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at brian@webiswhatido.com. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
## Attribution
This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version]
[homepage]: http://contributor-covenant.org
[version]: http://contributor-covenant.org/version/1/4/

1
vendor/github.com/brianvoe/gofakeit/v6/CONTRIBUTING.md generated vendored Normal file
View File

@ -0,0 +1 @@
# Make a pull request and submit it and ill take a look at it. Thanks!

20
vendor/github.com/brianvoe/gofakeit/v6/LICENSE.txt generated vendored Normal file
View File

@ -0,0 +1,20 @@
The MIT License (MIT)
Copyright (c) [year] [fullname]
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
the Software, and to permit persons to whom the Software is furnished to do so,
subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

851
vendor/github.com/brianvoe/gofakeit/v6/README.md generated vendored Normal file
View File

@ -0,0 +1,851 @@
![alt text](https://raw.githubusercontent.com/brianvoe/gofakeit/master/logo.png)
# Gofakeit [![Go Report Card](https://goreportcard.com/badge/github.com/brianvoe/gofakeit)](https://goreportcard.com/report/github.com/brianvoe/gofakeit) ![Test](https://github.com/brianvoe/gofakeit/workflows/Test/badge.svg?branch=master) [![GoDoc](https://godoc.org/github.com/brianvoe/gofakeit/v6?status.svg)](https://godoc.org/github.com/brianvoe/gofakeit/v6) [![license](http://img.shields.io/badge/license-MIT-green.svg?style=flat)](https://raw.githubusercontent.com/brianvoe/gofakeit/master/LICENSE.txt)
Random data generator written in go
[![ko-fi](https://ko-fi.com/img/githubbutton_sm.svg)](https://ko-fi.com/G2G0R5EJT)
<a href="https://www.buymeacoffee.com/brianvoe" target="_blank"><img src="https://www.buymeacoffee.com/assets/img/custom_images/orange_img.png" alt="Buy Me A Coffee" style="height: auto !important;width: auto !important;" ></a>
## Features
- [310+ Functions!!!](#functions)
- [Random Sources](#random-sources)
- [Global Rand](#global-rand-set)
- [Struct Generator](#struct)
- [Custom Functions](#custom-functions)
- [Templates](#templates)
- [Http Server](https://github.com/brianvoe/gofakeit/tree/master/cmd/gofakeitserver)
- [Command Line Tool](https://github.com/brianvoe/gofakeit/tree/master/cmd/gofakeit)
- Zero dependencies
- [Benchmarks](https://github.com/brianvoe/gofakeit/blob/master/BENCHMARKS.md)
- [Issue](https://github.com/brianvoe/gofakeit/issues)
## Contributors
Thank you to all our Gofakeit contributors!
<a href="https://github.com/brianvoe/gofakeit/graphs/contributors">
<img src="https://contrib.rocks/image?repo=brianvoe/gofakeit" />
</a>
## Installation
```go
go get github.com/brianvoe/gofakeit/v6
```
## Simple Usage
```go
import "github.com/brianvoe/gofakeit/v6"
gofakeit.Name() // Markus Moen
gofakeit.Email() // alaynawuckert@kozey.biz
gofakeit.Phone() // (570)245-7485
gofakeit.BS() // front-end
gofakeit.BeerName() // Duvel
gofakeit.Color() // MediumOrchid
gofakeit.Company() // Moen, Pagac and Wuckert
gofakeit.CreditCardNumber() // 4287271570245748
gofakeit.HackerPhrase() // Connecting the array won't do anything, we need to generate the haptic COM driver!
gofakeit.JobTitle() // Director
gofakeit.CurrencyShort() // USD
```
[See full list of functions](#functions)
## Seed
If you are using the default global usage and dont care about seeding no need to set anything.
Gofakeit will seed it with a cryptographically secure number.
If you need a reproducible outcome you can set it via the Seed function call. Every example in
this repo sets it for testing purposes.
```go
import "github.com/brianvoe/gofakeit/v6"
gofakeit.Seed(0) // If 0 will use crypto/rand to generate a number
// or
gofakeit.Seed(8675309) // Set it to whatever number you want
```
## Random Sources
Gofakeit has a few rand sources, by default it uses math.Rand and uses mutex locking to allow for safe goroutines.
If you want to use a more performant source please use NewUnlocked. Be aware that it is not goroutine safe.
```go
import "github.com/brianvoe/gofakeit/v6"
// Uses math/rand(Pseudo) with mutex locking
faker := gofakeit.New(0)
// Uses math/rand(Pseudo) with NO mutext locking
// More performant but not goroutine safe.
faker := gofakeit.NewUnlocked(0)
// Uses crypto/rand(cryptographically secure) with mutext locking
faker := gofakeit.NewCrypto()
// Pass in your own random source
faker := gofakeit.NewCustom()
```
## Global Rand Set
If you would like to use the simple function calls but need to use something like
crypto/rand you can override the default global with the random source that you want.
```go
import "github.com/brianvoe/gofakeit/v6"
faker := gofakeit.NewCrypto()
gofakeit.SetGlobalFaker(faker)
```
## Struct
Gofakeit can generate random data for struct fields. For the most part it covers all the basic type
as well as some non-basic like time.Time.
Struct fields can also use tags to more specifically generate data for that field type.
```go
import "github.com/brianvoe/gofakeit/v6"
// Create structs with random injected data
type Foo struct {
Str string
Int int
Pointer *int
Name string `fake:"{firstname}"` // Any available function all lowercase
Sentence string `fake:"{sentence:3}"` // Can call with parameters
RandStr string `fake:"{randomstring:[hello,world]}"`
Number string `fake:"{number:1,10}"` // Comma separated for multiple values
Regex string `fake:"{regex:[abcdef]{5}}"` // Generate string from regex
Map map[string]int `fakesize:"2"`
Array []string `fakesize:"2"`
ArrayRange []string `fakesize:"2,6"`
Bar Bar
Skip *string `fake:"skip"` // Set to "skip" to not generate data for
SkipAlt *string `fake:"-"` // Set to "-" to not generate data for
Created time.Time // Can take in a fake tag as well as a format tag
CreatedFormat time.Time `fake:"{year}-{month}-{day}" format:"2006-01-02"`
}
type Bar struct {
Name string
Number int
Float float32
}
// Pass your struct as a pointer
var f Foo
gofakeit.Struct(&f)
fmt.Println(f.Str) // hrukpttuezptneuvunh
fmt.Println(f.Int) // -7825289004089916589
fmt.Println(*f.Pointer) // -343806609094473732
fmt.Println(f.Name) // fred
fmt.Println(f.Sentence) // Record river mind.
fmt.Println(f.RandStr) // world
fmt.Println(f.Number) // 4
fmt.Println(f.Regex) // cbdfc
fmt.Println(f.Map) // map[PxLIo:52 lxwnqhqc:846]
fmt.Println(f.Array) // cbdfc
fmt.Printf("%+v", f.Bar) // {Name:QFpZ Number:-2882647639396178786 Float:1.7636692e+37}
fmt.Println(f.Skip) // <nil>
fmt.Println(f.Created.String()) // 1908-12-07 04:14:25.685339029 +0000 UTC
// Supported formats
// int, int8, int16, int32, int64,
// uint, uint8, uint16, uint32, uint64,
// float32, float64,
// bool, string,
// array, pointers, map
// time.Time // If setting time you can also set a format tag
// Nested Struct Fields and Embedded Fields
```
## Fakeable types
It is possible to extend a struct by implementing the `Fakeable` interface
in order to control the generation.
For example, this is useful when it is not possible to modify the struct that you want to fake by adding struct tags to a field but you still need to be able to control the generation process.
```go
// Custom string that you want to generate your own data for
// or just return a static value
type CustomString string
func (c *CustomString) Fake(faker *gofakeit.Faker) (any, error) {
return CustomString("my custom string")
}
// Imagine a CustomTime type that is needed to support a custom JSON Marshaler
type CustomTime time.Time
func (c *CustomTime) Fake(faker *gofakeit.Faker) (any, error) {
return CustomTime(time.Now())
}
func (c *CustomTime) MarshalJSON() ([]byte, error) {
//...
}
// This is the struct that we cannot modify to add struct tags
type NotModifiable struct {
Token string
Value CustomString
Creation *CustomTime
}
var f NotModifiable
gofakeit.Struct(&f)
fmt.Printf("%s", f.Token) // yvqqdH
fmt.Printf("%s", f.Value) // my custom string
fmt.Printf("%s", f.Creation) // 2023-04-02 23:00:00 +0000 UTC m=+0.000000001
```
## Custom Functions
In a lot of situations you may need to use your own random function usage for your specific needs.
If you would like to extend the usage of struct tags, generate function, available usages in the gofakeit server
or gofakeit command sub packages. You can do so via the AddFuncLookup. Each function has their own lookup, if
you need more reference examples you can look at each files lookups.
```go
// Simple
gofakeit.AddFuncLookup("friendname", gofakeit.Info{
Category: "custom",
Description: "Random friend name",
Example: "bill",
Output: "string",
Generate: func(r *rand.Rand, m *gofakeit.MapParams, info *gofakeit.Info) (any, error) {
return gofakeit.RandomString([]string{"bill", "bob", "sally"}), nil
},
})
// With Params
gofakeit.AddFuncLookup("jumbleword", gofakeit.Info{
Category: "jumbleword",
Description: "Take a word and jumble it up",
Example: "loredlowlh",
Output: "string",
Params: []gofakeit.Param{
{Field: "word", Type: "string", Description: "Word you want to jumble"},
},
Generate: func(r *rand.Rand, m *gofakeit.MapParams, info *gofakeit.Info) (any, error) {
word, err := info.GetString(m, "word")
if err != nil {
return nil, err
}
split := strings.Split(word, "")
gofakeit.ShuffleStrings(split)
return strings.Join(split, ""), nil
},
})
type Foo struct {
FriendName string `fake:"{friendname}"`
JumbleWord string `fake:"{jumbleword:helloworld}"`
}
var f Foo
gofakeit.Struct(&f)
fmt.Printf("%s", f.FriendName) // bill
fmt.Printf("%s", f.JumbleWord) // loredlowlh
```
## Templates
Generate custom outputs using golang's template engine [https://pkg.go.dev/text/template](https://pkg.go.dev/text/template).
We have added all the available functions to the template engine as well as some additional ones that are useful for template building.
Additional Available Functions
```go
- ToUpper(s string) string // Make string upper case
- ToLower(s string) string // Make string lower case
- ToString(s any) // Convert to string
- ToDate(s string) time.Time // Convert string to date
- SpliceAny(args ...any) []any // Build a slice of anys, used with Weighted
- SpliceString(args ...string) []string // Build a slice of strings, used with Teams and RandomString
- SpliceUInt(args ...uint) []uint // Build a slice of uint, used with Dice and RandomUint
- SpliceInt(args ...int) []int // Build a slice of int, used with RandomInt
```
<details>
<summary>Unavailable Gofakeit functions</summary>
```go
// Any functions that dont have a return value
- AnythingThatReturnsVoid(): void
// Not available to use in templates
- Template(co *TemplateOptions) ([]byte, error)
- RandomMapKey(mapI any) any
```
</details>
### Example Usages
```go
import "github.com/brianvoe/gofakeit/v6"
func main() {
// Accessing the Lines variable from within the template.
template := `
Subject: {{RandomString (SliceString "Greetings" "Hello" "Hi")}}
Dear {{LastName}},
{{RandomString (SliceString "Greetings!" "Hello there!" "Hi, how are you?")}}
{{Paragraph 1 5 10 "\n\n"}}
{{RandomString (SliceString "Warm regards" "Best wishes" "Sincerely")}}
{{$person:=Person}}
{{$person.FirstName}} {{$person.LastName}}
{{$person.Email}}
{{$person.Phone}}
`
value, err := gofakeit.Template(template, &TemplateOptions{Data: 5})
if err != nil {
fmt.Println(err)
}
fmt.Println(string(value))
}
```
Output:
```text
Subject: Hello
Dear Krajcik,
Greetings!
Quia voluptatem voluptatem voluptatem. Quia voluptatem voluptatem voluptatem. Quia voluptatem voluptatem voluptatem.
Warm regards
Kaitlyn Krajcik
kaitlynkrajcik@krajcik
570-245-7485
```
## Functions
All functions also exist as methods on the Faker struct
### File
Passing `nil` to `CSV`, `JSON` or `XML` will auto generate data using default values.
```go
CSV(co *CSVOptions) ([]byte, error)
JSON(jo *JSONOptions) ([]byte, error)
XML(xo *XMLOptions) ([]byte, error)
FileExtension() string
FileMimeType() string
```
### Template
Passing `nil` will auto generate data using default values.
```go
Template(co *TemplateOptions) (string, error)
Markdown(co *MarkdownOptions) (string, error)
EmailText(co *EmailOptions) (string, error)
FixedWidth(co *FixedWidthOptions) (string, error)
```
### Product
```go
Product() *ProductInfo
ProductName() string
ProductDescription() string
ProductCategory() string
ProductFeature() string
ProductMaterial() string
```
### Person
```go
Person() *PersonInfo
Name() string
NamePrefix() string
NameSuffix() string
FirstName() string
MiddleName() string
LastName() string
Gender() string
SSN() string
Hobby() string
Contact() *ContactInfo
Email() string
Phone() string
PhoneFormatted() string
Teams(peopleArray []string, teamsArray []string) map[string][]string
```
### Generate
```go
Struct(v any)
Slice(v any)
Map() map[string]any
Generate(value string) string
Regex(value string) string
```
### Auth
```go
Username() string
Password(lower bool, upper bool, numeric bool, special bool, space bool, num int) string
```
### Address
```go
Address() *AddressInfo
City() string
Country() string
CountryAbr() string
State() string
StateAbr() string
Street() string
StreetName() string
StreetNumber() string
StreetPrefix() string
StreetSuffix() string
Zip() string
Latitude() float64
LatitudeInRange(min, max float64) (float64, error)
Longitude() float64
LongitudeInRange(min, max float64) (float64, error)
```
### Game
```go
Gamertag() string
Dice(numDice uint, sides []uint) []uint
```
### Beer
```go
BeerAlcohol() string
BeerBlg() string
BeerHop() string
BeerIbu() string
BeerMalt() string
BeerName() string
BeerStyle() string
BeerYeast() string
```
### Car
```go
Car() *CarInfo
CarMaker() string
CarModel() string
CarType() string
CarFuelType() string
CarTransmissionType() string
```
### Words
```go
// Nouns
Noun() string
NounCommon() string
NounConcrete() string
NounAbstract() string
NounCollectivePeople() string
NounCollectiveAnimal() string
NounCollectiveThing() string
NounCountable() string
NounUncountable() string
// Verbs
Verb() string
VerbAction() string
VerbLinking() string
VerbHelping() string
// Adverbs
Adverb() string
AdverbManner() string
AdverbDegree() string
AdverbPlace() string
AdverbTimeDefinite() string
AdverbTimeIndefinite() string
AdverbFrequencyDefinite() string
AdverbFrequencyIndefinite() string
// Propositions
Preposition() string
PrepositionSimple() string
PrepositionDouble() string
PrepositionCompound() string
// Adjectives
Adjective() string
AdjectiveDescriptive() string
AdjectiveQuantitative() string
AdjectiveProper() string
AdjectiveDemonstrative() string
AdjectivePossessive() string
AdjectiveInterrogative() string
AdjectiveIndefinite() string
// Pronouns
Pronoun() string
PronounPersonal() string
PronounObject() string
PronounPossessive() string
PronounReflective() string
PronounDemonstrative() string
PronounInterrogative() string
PronounRelative() string
// Connectives
Connective() string
ConnectiveTime() string
ConnectiveComparative() string
ConnectiveComplaint() string
ConnectiveListing() string
ConnectiveCasual() string
ConnectiveExamplify() string
// Words
Word() string
// Sentences
Sentence(wordCount int) string
Paragraph(paragraphCount int, sentenceCount int, wordCount int, separator string) string
LoremIpsumWord() string
LoremIpsumSentence(wordCount int) string
LoremIpsumParagraph(paragraphCount int, sentenceCount int, wordCount int, separator string) string
Question() string
Quote() string
Phrase() string
```
### Foods
```go
Fruit() string
Vegetable() string
Breakfast() string
Lunch() string
Dinner() string
Snack() string
Dessert() string
```
### Misc
```go
Bool() bool
UUID() string
Weighted(options []any, weights []float32) (any, error)
FlipACoin() string
RandomMapKey(mapI any) any
ShuffleAnySlice(v any)
```
### Colors
```go
Color() string
HexColor() string
RGBColor() []int
SafeColor() string
NiceColors() string
```
### Images
```go
ImageURL(width int, height int) string
Image(width int, height int) *img.RGBA
ImageJpeg(width int, height int) []byte
ImagePng(width int, height int) []byte
```
### Internet
```go
URL() string
DomainName() string
DomainSuffix() string
IPv4Address() string
IPv6Address() string
MacAddress() string
HTTPStatusCode() string
HTTPStatusCodeSimple() int
LogLevel(logType string) string
HTTPMethod() string
HTTPVersion() string
UserAgent() string
ChromeUserAgent() string
FirefoxUserAgent() string
OperaUserAgent() string
SafariUserAgent() string
```
### HTML
```go
InputName() string
Svg(options *SVGOptions) string
```
### Date/Time
```go
Date() time.Time
PastDate() time.Time
FutureDate() time.Time
DateRange(start, end time.Time) time.Time
NanoSecond() int
Second() int
Minute() int
Hour() int
Month() int
MonthString() string
Day() int
WeekDay() string
Year() int
TimeZone() string
TimeZoneAbv() string
TimeZoneFull() string
TimeZoneOffset() float32
TimeZoneRegion() string
```
### Payment
```go
Price(min, max float64) float64
CreditCard() *CreditCardInfo
CreditCardCvv() string
CreditCardExp() string
CreditCardNumber(*CreditCardOptions) string
CreditCardType() string
Currency() *CurrencyInfo
CurrencyLong() string
CurrencyShort() string
AchRouting() string
AchAccount() string
BitcoinAddress() string
BitcoinPrivateKey() string
```
### Finance
```go
Cusip() string
Isin() string
```
### Company
```go
BS() string
Blurb() string
BuzzWord() string
Company() string
CompanySuffix() string
Job() *JobInfo
JobDescriptor() string
JobLevel() string
JobTitle() string
Slogan() string
```
### Hacker
```go
HackerAbbreviation() string
HackerAdjective() string
Hackeringverb() string
HackerNoun() string
HackerPhrase() string
HackerVerb() string
```
### Hipster
```go
HipsterWord() string
HipsterSentence(wordCount int) string
HipsterParagraph(paragraphCount int, sentenceCount int, wordCount int, separator string) string
```
### App
```go
AppName() string
AppVersion() string
AppAuthor() string
```
### Animal
```go
PetName() string
Animal() string
AnimalType() string
FarmAnimal() string
Cat() string
Dog() string
Bird() string
```
### Emoji
```go
Emoji() string
EmojiDescription() string
EmojiCategory() string
EmojiAlias() string
EmojiTag() string
```
### Language
```go
Language() string
LanguageAbbreviation() string
ProgrammingLanguage() string
ProgrammingLanguageBest() string
```
### Number
```go
Number(min int, max int) int
Int8() int8
Int16() int16
Int32() int32
Int64() int64
Uint8() uint8
Uint16() uint16
Uint32() uint32
Uint64() uint64
Float32() float32
Float32Range(min, max float32) float32
Float64() float64
Float64Range(min, max float64) float64
ShuffleInts(a []int)
RandomInt(i []int) int
HexUint8() string
HexUint16() string
HexUint32() string
HexUint64() string
HexUint128() string
HexUint256() string
```
### String
```go
Digit() string
DigitN(n uint) string
Letter() string
LetterN(n uint) string
Lexify(str string) string
Numerify(str string) string
ShuffleStrings(a []string)
RandomString(a []string) string
```
### Celebrity
```go
CelebrityActor() string
CelebrityBusiness() string
CelebritySport() string
```
### Minecraft
```go
MinecraftOre() string
MinecraftWood() string
MinecraftArmorTier() string
MinecraftArmorPart() string
MinecraftWeapon() string
MinecraftTool() string
MinecraftDye() string
MinecraftFood() string
MinecraftAnimal() string
MinecraftVillagerJob() string
MinecraftVillagerStation() string
MinecraftVillagerLevel() string
MinecraftMobPassive() string
MinecraftMobNeutral() string
MinecraftMobHostile() string
MinecraftMobBoss() string
MinecraftBiome() string
MinecraftWeather() string
```
### Book
```go
Book() *BookInfo
BookTitle() string
BookAuthor() string
BookGenre() string
```
### Movie
```go
Movie() *MovieInfo
MovieName() string
MovieGenre() string
```
### Error
```go
Error() error
ErrorDatabase() error
ErrorGRPC() error
ErrorHTTP() error
ErrorHTTPClient() error
ErrorHTTPServer() error
ErrorInput() error
ErrorRuntime() error
```
### School
```go
School() string
```

421
vendor/github.com/brianvoe/gofakeit/v6/address.go generated vendored Normal file
View File

@ -0,0 +1,421 @@
package gofakeit
import (
"errors"
"math/rand"
"strings"
)
// AddressInfo is a struct full of address information
type AddressInfo struct {
Address string `json:"address" xml:"address"`
Street string `json:"street" xml:"street"`
City string `json:"city" xml:"city"`
State string `json:"state" xml:"state"`
Zip string `json:"zip" xml:"zip"`
Country string `json:"country" xml:"country"`
Latitude float64 `json:"latitude" xml:"latitude"`
Longitude float64 `json:"longitude" xml:"longitude"`
}
// Address will generate a struct of address information
func Address() *AddressInfo { return address(globalFaker.Rand) }
// Address will generate a struct of address information
func (f *Faker) Address() *AddressInfo { return address(f.Rand) }
func address(r *rand.Rand) *AddressInfo {
street := street(r)
city := city(r)
state := state(r)
zip := zip(r)
return &AddressInfo{
Address: street + ", " + city + ", " + state + " " + zip,
Street: street,
City: city,
State: state,
Zip: zip,
Country: country(r),
Latitude: latitude(r),
Longitude: longitude(r),
}
}
// Street will generate a random address street string
func Street() string { return street(globalFaker.Rand) }
// Street will generate a random address street string
func (f *Faker) Street() string { return street(f.Rand) }
func street(r *rand.Rand) string {
var street = ""
switch randInt := randIntRange(r, 1, 2); randInt {
case 1:
street = streetNumber(r) + " " + streetPrefix(r) + " " + streetName(r) + streetSuffix(r)
case 2:
street = streetNumber(r) + " " + streetName(r) + streetSuffix(r)
}
return street
}
// StreetNumber will generate a random address street number string
func StreetNumber() string { return streetNumber(globalFaker.Rand) }
// StreetNumber will generate a random address street number string
func (f *Faker) StreetNumber() string { return streetNumber(f.Rand) }
func streetNumber(r *rand.Rand) string {
return strings.TrimLeft(replaceWithNumbers(r, getRandValue(r, []string{"address", "number"})), "0")
}
// StreetPrefix will generate a random address street prefix string
func StreetPrefix() string { return streetPrefix(globalFaker.Rand) }
// StreetPrefix will generate a random address street prefix string
func (f *Faker) StreetPrefix() string { return streetPrefix(f.Rand) }
func streetPrefix(r *rand.Rand) string { return getRandValue(r, []string{"address", "street_prefix"}) }
// StreetName will generate a random address street name string
func StreetName() string { return streetName(globalFaker.Rand) }
// StreetName will generate a random address street name string
func (f *Faker) StreetName() string { return streetName(f.Rand) }
func streetName(r *rand.Rand) string { return getRandValue(r, []string{"address", "street_name"}) }
// StreetSuffix will generate a random address street suffix string
func StreetSuffix() string { return streetSuffix(globalFaker.Rand) }
// StreetSuffix will generate a random address street suffix string
func (f *Faker) StreetSuffix() string { return streetSuffix(f.Rand) }
func streetSuffix(r *rand.Rand) string { return getRandValue(r, []string{"address", "street_suffix"}) }
// City will generate a random city string
func City() string { return city(globalFaker.Rand) }
// City will generate a random city string
func (f *Faker) City() string { return city(f.Rand) }
func city(r *rand.Rand) string { return getRandValue(r, []string{"address", "city"}) }
// State will generate a random state string
func State() string { return state(globalFaker.Rand) }
// State will generate a random state string
func (f *Faker) State() string { return state(f.Rand) }
func state(r *rand.Rand) string { return getRandValue(r, []string{"address", "state"}) }
// StateAbr will generate a random abbreviated state string
func StateAbr() string { return stateAbr(globalFaker.Rand) }
// StateAbr will generate a random abbreviated state string
func (f *Faker) StateAbr() string { return stateAbr(f.Rand) }
func stateAbr(r *rand.Rand) string { return getRandValue(r, []string{"address", "state_abr"}) }
// Zip will generate a random Zip code string
func Zip() string { return zip(globalFaker.Rand) }
// Zip will generate a random Zip code string
func (f *Faker) Zip() string { return zip(f.Rand) }
func zip(r *rand.Rand) string {
return replaceWithNumbers(r, getRandValue(r, []string{"address", "zip"}))
}
// Country will generate a random country string
func Country() string { return country(globalFaker.Rand) }
// Country will generate a random country string
func (f *Faker) Country() string { return country(f.Rand) }
func country(r *rand.Rand) string { return getRandValue(r, []string{"address", "country"}) }
// CountryAbr will generate a random abbreviated country string
func CountryAbr() string { return countryAbr(globalFaker.Rand) }
// CountryAbr will generate a random abbreviated country string
func (f *Faker) CountryAbr() string { return countryAbr(f.Rand) }
func countryAbr(r *rand.Rand) string { return getRandValue(r, []string{"address", "country_abr"}) }
// Latitude will generate a random latitude float64
func Latitude() float64 { return latitude(globalFaker.Rand) }
// Latitude will generate a random latitude float64
func (f *Faker) Latitude() float64 { return latitude(f.Rand) }
func latitude(r *rand.Rand) float64 { return toFixed((r.Float64()*180)-90, 6) }
// LatitudeInRange will generate a random latitude within the input range
func LatitudeInRange(min, max float64) (float64, error) {
return latitudeInRange(globalFaker.Rand, min, max)
}
// LatitudeInRange will generate a random latitude within the input range
func (f *Faker) LatitudeInRange(min, max float64) (float64, error) {
return latitudeInRange(f.Rand, min, max)
}
func latitudeInRange(r *rand.Rand, min, max float64) (float64, error) {
if min > max || min < -90 || min > 90 || max < -90 || max > 90 {
return 0, errors.New("invalid min or max range, must be valid floats and between -90 and 90")
}
return toFixed(float64Range(r, min, max), 6), nil
}
// Longitude will generate a random longitude float64
func Longitude() float64 { return longitude(globalFaker.Rand) }
// Longitude will generate a random longitude float64
func (f *Faker) Longitude() float64 { return longitude(f.Rand) }
func longitude(r *rand.Rand) float64 { return toFixed((r.Float64()*360)-180, 6) }
// LongitudeInRange will generate a random longitude within the input range
func LongitudeInRange(min, max float64) (float64, error) {
return longitudeInRange(globalFaker.Rand, min, max)
}
// LongitudeInRange will generate a random longitude within the input range
func (f *Faker) LongitudeInRange(min, max float64) (float64, error) {
return longitudeInRange(f.Rand, min, max)
}
func longitudeInRange(r *rand.Rand, min, max float64) (float64, error) {
if min > max || min < -180 || min > 180 || max < -180 || max > 180 {
return 0, errors.New("invalid min or max range, must be valid floats and between -180 and 180")
}
return toFixed(float64Range(r, min, max), 6), nil
}
func addAddressLookup() {
AddFuncLookup("address", Info{
Display: "Address",
Category: "address",
Description: "Residential location including street, city, state, country and postal code",
Example: `{
"address": "364 Unionsville, Norfolk, Ohio 99536",
"street": "364 Unionsville",
"city": "Norfolk",
"state": "Ohio",
"zip": "99536",
"country": "Lesotho",
"latitude": 88.792592,
"longitude": 174.504681
}`,
Output: "map[string]any",
ContentType: "application/json",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return address(r), nil
},
})
AddFuncLookup("city", Info{
Display: "City",
Category: "address",
Description: "Part of a country with significant population, often a central hub for culture and commerce",
Example: "Marcelside",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return city(r), nil
},
})
AddFuncLookup("country", Info{
Display: "Country",
Category: "address",
Description: "Nation with its own government and defined territory",
Example: "United States of America",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return country(r), nil
},
})
AddFuncLookup("countryabr", Info{
Display: "Country Abbreviation",
Category: "address",
Description: "Shortened 2-letter form of a country's name",
Example: "US",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return countryAbr(r), nil
},
})
AddFuncLookup("state", Info{
Display: "State",
Category: "address",
Description: "Governmental division within a country, often having its own laws and government",
Example: "Illinois",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return state(r), nil
},
})
AddFuncLookup("stateabr", Info{
Display: "State Abbreviation",
Category: "address",
Description: "Shortened 2-letter form of a country's state",
Example: "IL",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return stateAbr(r), nil
},
})
AddFuncLookup("street", Info{
Display: "Street",
Category: "address",
Description: "Public road in a city or town, typically with houses and buildings on each side",
Example: "364 East Rapidsborough",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return street(r), nil
},
})
AddFuncLookup("streetname", Info{
Display: "Street Name",
Category: "address",
Description: "Name given to a specific road or street",
Example: "View",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return streetName(r), nil
},
})
AddFuncLookup("streetnumber", Info{
Display: "Street Number",
Category: "address",
Description: "Numerical identifier assigned to a street",
Example: "13645",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return streetNumber(r), nil
},
})
AddFuncLookup("streetprefix", Info{
Display: "Street Prefix",
Category: "address",
Description: "Directional or descriptive term preceding a street name, like 'East' or 'Main'",
Example: "Lake",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return streetPrefix(r), nil
},
})
AddFuncLookup("streetsuffix", Info{
Display: "Street Suffix",
Category: "address",
Description: "Designation at the end of a street name indicating type, like 'Avenue' or 'Street'",
Example: "land",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return streetSuffix(r), nil
},
})
AddFuncLookup("zip", Info{
Display: "Zip",
Category: "address",
Description: "Numerical code for postal address sorting, specific to a geographic area",
Example: "13645",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return zip(r), nil
},
})
AddFuncLookup("latitude", Info{
Display: "Latitude",
Category: "address",
Description: "Geographic coordinate specifying north-south position on Earth's surface",
Example: "-73.534056",
Output: "float",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return latitude(r), nil
},
})
AddFuncLookup("latituderange", Info{
Display: "Latitude Range",
Category: "address",
Description: "Latitude number between the given range (default min=0, max=90)",
Example: "22.921026",
Output: "float",
Params: []Param{
{Field: "min", Display: "Min", Type: "float", Default: "0", Description: "Minimum range"},
{Field: "max", Display: "Max", Type: "float", Default: "90", Description: "Maximum range"},
},
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
min, err := info.GetFloat64(m, "min")
if err != nil {
return nil, err
}
max, err := info.GetFloat64(m, "max")
if err != nil {
return nil, err
}
rangeOut, err := latitudeInRange(r, min, max)
if err != nil {
return nil, err
}
return rangeOut, nil
},
})
AddFuncLookup("longitude", Info{
Display: "Longitude",
Category: "address",
Description: "Geographic coordinate indicating east-west position on Earth's surface",
Example: "-147.068112",
Output: "float",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return longitude(r), nil
},
})
AddFuncLookup("longituderange", Info{
Display: "Longitude Range",
Category: "address",
Description: "Longitude number between the given range (default min=0, max=180)",
Example: "-8.170450",
Output: "float",
Params: []Param{
{Field: "min", Display: "Min", Type: "float", Default: "0", Description: "Minimum range"},
{Field: "max", Display: "Max", Type: "float", Default: "180", Description: "Maximum range"},
},
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
min, err := info.GetFloat64(m, "min")
if err != nil {
return nil, err
}
max, err := info.GetFloat64(m, "max")
if err != nil {
return nil, err
}
rangeOut, err := longitudeInRange(r, min, max)
if err != nil {
return nil, err
}
return rangeOut, nil
},
})
}

180
vendor/github.com/brianvoe/gofakeit/v6/animal.go generated vendored Normal file
View File

@ -0,0 +1,180 @@
package gofakeit
import "math/rand"
// PetName will return a random fun pet name
func PetName() string {
return petName(globalFaker.Rand)
}
// PetName will return a random fun pet name
func (f *Faker) PetName() string {
return petName(f.Rand)
}
func petName(r *rand.Rand) string {
return getRandValue(r, []string{"animal", "petname"})
}
// Animal will return a random animal
func Animal() string {
return animal(globalFaker.Rand)
}
// Animal will return a random animal
func (f *Faker) Animal() string {
return animal(f.Rand)
}
func animal(r *rand.Rand) string {
return getRandValue(r, []string{"animal", "animal"})
}
// AnimalType will return a random animal type
func AnimalType() string {
return animalType(globalFaker.Rand)
}
// AnimalType will return a random animal type
func (f *Faker) AnimalType() string {
return animalType(f.Rand)
}
func animalType(r *rand.Rand) string {
return getRandValue(r, []string{"animal", "type"})
}
// FarmAnimal will return a random animal that usually lives on a farm
func FarmAnimal() string {
return farmAnimal(globalFaker.Rand)
}
// FarmAnimal will return a random animal that usually lives on a farm
func (f *Faker) FarmAnimal() string {
return farmAnimal(f.Rand)
}
func farmAnimal(r *rand.Rand) string {
return getRandValue(r, []string{"animal", "farm"})
}
// Cat will return a random cat breed
func Cat() string {
return cat(globalFaker.Rand)
}
// Cat will return a random cat breed
func (f *Faker) Cat() string {
return cat(f.Rand)
}
func cat(r *rand.Rand) string {
return getRandValue(r, []string{"animal", "cat"})
}
// Dog will return a random dog breed
func Dog() string {
return dog(globalFaker.Rand)
}
// Dog will return a random dog breed
func (f *Faker) Dog() string {
return dog(f.Rand)
}
func dog(r *rand.Rand) string {
return getRandValue(r, []string{"animal", "dog"})
}
// Bird will return a random bird species
func Bird() string {
return bird(globalFaker.Rand)
}
// Bird will return a random bird species
func (f *Faker) Bird() string {
return bird(f.Rand)
}
func bird(r *rand.Rand) string {
return getRandValue(r, []string{"animal", "bird"})
}
func addAnimalLookup() {
AddFuncLookup("petname", Info{
Display: "Pet Name",
Category: "animal",
Description: "Affectionate nickname given to a pet",
Example: "Ozzy Pawsborne",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return petName(r), nil
},
})
AddFuncLookup("animal", Info{
Display: "Animal",
Category: "animal",
Description: "Living creature with the ability to move, eat, and interact with its environment",
Example: "elk",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return animal(r), nil
},
})
AddFuncLookup("animaltype", Info{
Display: "Animal Type",
Category: "animal",
Description: "Type of animal, such as mammals, birds, reptiles, etc.",
Example: "amphibians",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return animalType(r), nil
},
})
AddFuncLookup("farmanimal", Info{
Display: "Farm Animal",
Category: "animal",
Description: "Animal name commonly found on a farm",
Example: "Chicken",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return farmAnimal(r), nil
},
})
AddFuncLookup("cat", Info{
Display: "Cat",
Category: "animal",
Description: "Various breeds that define different cats",
Example: "Chausie",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return cat(r), nil
},
})
AddFuncLookup("dog", Info{
Display: "Dog",
Category: "animal",
Description: "Various breeds that define different dogs",
Example: "Norwich Terrier",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return dog(r), nil
},
})
AddFuncLookup("bird", Info{
Display: "Bird",
Category: "animal",
Description: "Distinct species of birds",
Example: "goose",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return bird(r), nil
},
})
}

97
vendor/github.com/brianvoe/gofakeit/v6/app.go generated vendored Normal file
View File

@ -0,0 +1,97 @@
package gofakeit
import (
"fmt"
"math/rand"
)
// AppName will generate a random app name
func AppName() string {
return appName(globalFaker.Rand)
}
// AppName will generate a random app name
func (f *Faker) AppName() string {
return appName(f.Rand)
}
func appName(r *rand.Rand) string {
name := ""
switch number(r, 1, 3) {
case 1:
name = noun(r) + verb(r)
case 2:
name = color(r) + noun(r)
case 3:
name = animal(r) + verb(r)
}
return title(name)
}
// AppVersion will generate a random app version
func AppVersion() string {
return appVersion(globalFaker.Rand)
}
// AppVersion will generate a random app version
func (f *Faker) AppVersion() string {
return appVersion(f.Rand)
}
func appVersion(r *rand.Rand) string {
return fmt.Sprintf("%d.%d.%d", number(r, 1, 5), number(r, 1, 20), number(r, 1, 20))
}
// AppAuthor will generate a random company or person name
func AppAuthor() string {
return appAuthor(globalFaker.Rand)
}
// AppAuthor will generate a random company or person name
func (f *Faker) AppAuthor() string {
return appAuthor(f.Rand)
}
func appAuthor(r *rand.Rand) string {
if boolFunc(r) {
return name(r)
}
return company(r)
}
func addAppLookup() {
AddFuncLookup("appname", Info{
Display: "App Name",
Category: "app",
Description: "Software program designed for a specific purpose or task on a computer or mobile device",
Example: "Parkrespond",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return appName(r), nil
},
})
AddFuncLookup("appversion", Info{
Display: "App Version",
Category: "app",
Description: "Particular release of an application in Semantic Versioning format",
Example: "1.12.14",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return appVersion(r), nil
},
})
AddFuncLookup("appauthor", Info{
Display: "App Author",
Category: "app",
Description: "Person or group creating and developing an application",
Example: "Qado Energy, Inc.",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return appAuthor(r), nil
},
})
}

165
vendor/github.com/brianvoe/gofakeit/v6/auth.go generated vendored Normal file
View File

@ -0,0 +1,165 @@
package gofakeit
import "math/rand"
// Username will generate a random username based upon picking a random lastname and random numbers at the end
func Username() string {
return username(globalFaker.Rand)
}
// Username will generate a random username based upon picking a random lastname and random numbers at the end
func (f *Faker) Username() string {
return username(f.Rand)
}
func username(r *rand.Rand) string {
return getRandValue(r, []string{"person", "last"}) + replaceWithNumbers(r, "####")
}
// Password will generate a random password.
// Minimum number length of 5 if less than.
func Password(lower bool, upper bool, numeric bool, special bool, space bool, num int) string {
return password(globalFaker.Rand, lower, upper, numeric, special, space, num)
}
// Password will generate a random password.
// Minimum number length of 5 if less than.
func (f *Faker) Password(lower bool, upper bool, numeric bool, special bool, space bool, num int) string {
return password(f.Rand, lower, upper, numeric, special, space, num)
}
func password(r *rand.Rand, lower bool, upper bool, numeric bool, special bool, space bool, num int) string {
// Make sure the num minimum is at least 5
if num < 5 {
num = 5
}
// Setup weights
items := make([]any, 0)
weights := make([]float32, 0)
if lower {
items = append(items, "lower")
weights = append(weights, 4)
}
if upper {
items = append(items, "upper")
weights = append(weights, 4)
}
if numeric {
items = append(items, "numeric")
weights = append(weights, 3)
}
if special {
items = append(items, "special")
weights = append(weights, 2)
}
if space {
items = append(items, "space")
weights = append(weights, 1)
}
// If no items are selected then default to lower, upper, numeric
if len(items) == 0 {
items = append(items, "lower", "upper", "numeric")
weights = append(weights, 4, 4, 3)
}
// Create byte slice
b := make([]byte, num)
for i := 0; i <= num-1; i++ {
// Run weighted
weight, _ := weighted(r, items, weights)
switch weight.(string) {
case "lower":
b[i] = lowerStr[r.Int63()%int64(len(lowerStr))]
case "upper":
b[i] = upperStr[r.Int63()%int64(len(upperStr))]
case "numeric":
b[i] = numericStr[r.Int63()%int64(len(numericStr))]
case "special":
b[i] = specialSafeStr[r.Int63()%int64(len(specialSafeStr))]
case "space":
b[i] = spaceStr[r.Int63()%int64(len(spaceStr))]
}
}
// Shuffle bytes
for i := range b {
j := r.Intn(i + 1)
b[i], b[j] = b[j], b[i]
}
// Replace first or last character if it's a space, and other options are available
if b[0] == ' ' {
b[0] = password(r, lower, upper, numeric, special, false, 1)[0]
}
if b[len(b)-1] == ' ' {
b[len(b)-1] = password(r, lower, upper, numeric, special, false, 1)[0]
}
return string(b)
}
func addAuthLookup() {
AddFuncLookup("username", Info{
Display: "Username",
Category: "auth",
Description: "Unique identifier assigned to a user for accessing an account or system",
Example: "Daniel1364",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return username(r), nil
},
})
AddFuncLookup("password", Info{
Display: "Password",
Category: "auth",
Description: "Secret word or phrase used to authenticate access to a system or account",
Example: "EEP+wwpk 4lU-eHNXlJZ4n K9%v&TZ9e",
Output: "string",
Params: []Param{
{Field: "lower", Display: "Lower", Type: "bool", Default: "true", Description: "Whether or not to add lower case characters"},
{Field: "upper", Display: "Upper", Type: "bool", Default: "true", Description: "Whether or not to add upper case characters"},
{Field: "numeric", Display: "Numeric", Type: "bool", Default: "true", Description: "Whether or not to add numeric characters"},
{Field: "special", Display: "Special", Type: "bool", Default: "true", Description: "Whether or not to add special characters"},
{Field: "space", Display: "Space", Type: "bool", Default: "false", Description: "Whether or not to add spaces"},
{Field: "length", Display: "Length", Type: "int", Default: "12", Description: "Number of characters in password"},
},
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
lower, err := info.GetBool(m, "lower")
if err != nil {
return nil, err
}
upper, err := info.GetBool(m, "upper")
if err != nil {
return nil, err
}
numeric, err := info.GetBool(m, "numeric")
if err != nil {
return nil, err
}
special, err := info.GetBool(m, "special")
if err != nil {
return nil, err
}
space, err := info.GetBool(m, "space")
if err != nil {
return nil, err
}
length, err := info.GetInt(m, "length")
if err != nil {
return nil, err
}
return password(r, lower, upper, numeric, special, space, length), nil
},
})
}

208
vendor/github.com/brianvoe/gofakeit/v6/beer.go generated vendored Normal file
View File

@ -0,0 +1,208 @@
package gofakeit
import (
"math/rand"
"strconv"
)
// BeerName will return a random beer name
func BeerName() string {
return beerName(globalFaker.Rand)
}
// BeerName will return a random beer name
func (f *Faker) BeerName() string {
return beerName(f.Rand)
}
func beerName(r *rand.Rand) string {
return getRandValue(r, []string{"beer", "name"})
}
// BeerStyle will return a random beer style
func BeerStyle() string {
return beerStyle(globalFaker.Rand)
}
// BeerStyle will return a random beer style
func (f *Faker) BeerStyle() string {
return beerStyle(f.Rand)
}
func beerStyle(r *rand.Rand) string {
return getRandValue(r, []string{"beer", "style"})
}
// BeerHop will return a random beer hop
func BeerHop() string {
return beerHop(globalFaker.Rand)
}
// BeerHop will return a random beer hop
func (f *Faker) BeerHop() string {
return beerHop(f.Rand)
}
func beerHop(r *rand.Rand) string {
return getRandValue(r, []string{"beer", "hop"})
}
// BeerYeast will return a random beer yeast
func BeerYeast() string {
return beerYeast(globalFaker.Rand)
}
// BeerYeast will return a random beer yeast
func (f *Faker) BeerYeast() string {
return beerYeast(f.Rand)
}
func beerYeast(r *rand.Rand) string {
return getRandValue(r, []string{"beer", "yeast"})
}
// BeerMalt will return a random beer malt
func BeerMalt() string {
return beerMalt(globalFaker.Rand)
}
// BeerMalt will return a random beer malt
func (f *Faker) BeerMalt() string {
return beerMalt(f.Rand)
}
func beerMalt(r *rand.Rand) string {
return getRandValue(r, []string{"beer", "malt"})
}
// BeerAlcohol will return a random beer alcohol level between 2.0 and 10.0
func BeerAlcohol() string {
return beerAlcohol(globalFaker.Rand)
}
// BeerAlcohol will return a random beer alcohol level between 2.0 and 10.0
func (f *Faker) BeerAlcohol() string {
return beerAlcohol(f.Rand)
}
func beerAlcohol(r *rand.Rand) string {
return strconv.FormatFloat(float64Range(r, 2.0, 10.0), 'f', 1, 64) + "%"
}
// BeerIbu will return a random beer ibu value between 10 and 100
func BeerIbu() string {
return beerIbu(globalFaker.Rand)
}
// BeerIbu will return a random beer ibu value between 10 and 100
func (f *Faker) BeerIbu() string {
return beerIbu(f.Rand)
}
func beerIbu(r *rand.Rand) string {
return strconv.Itoa(randIntRange(r, 10, 100)) + " IBU"
}
// BeerBlg will return a random beer blg between 5.0 and 20.0
func BeerBlg() string {
return beerBlg(globalFaker.Rand)
}
// BeerBlg will return a random beer blg between 5.0 and 20.0
func (f *Faker) BeerBlg() string {
return beerBlg(f.Rand)
}
func beerBlg(r *rand.Rand) string {
return strconv.FormatFloat(float64Range(r, 5.0, 20.0), 'f', 1, 64) + "°Blg"
}
func addBeerLookup() {
AddFuncLookup("beername", Info{
Display: "Beer Name",
Category: "beer",
Description: "Specific brand or variety of beer",
Example: "Duvel",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return beerName(r), nil
},
})
AddFuncLookup("beerstyle", Info{
Display: "Beer Style",
Category: "beer",
Description: "Distinct characteristics and flavors of beer",
Example: "European Amber Lager",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return beerStyle(r), nil
},
})
AddFuncLookup("beerhop", Info{
Display: "Beer Hop",
Category: "beer",
Description: "The flower used in brewing to add flavor, aroma, and bitterness to beer",
Example: "Glacier",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return beerHop(r), nil
},
})
AddFuncLookup("beeryeast", Info{
Display: "Beer Yeast",
Category: "beer",
Description: "Microorganism used in brewing to ferment sugars, producing alcohol and carbonation in beer",
Example: "1388 - Belgian Strong Ale",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return beerYeast(r), nil
},
})
AddFuncLookup("beermalt", Info{
Display: "Beer Malt",
Category: "beer",
Description: "Processed barley or other grains, provides sugars for fermentation and flavor to beer",
Example: "Munich",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return beerMalt(r), nil
},
})
AddFuncLookup("beeralcohol", Info{
Display: "Beer Alcohol",
Category: "beer",
Description: "Measures the alcohol content in beer",
Example: "2.7%",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return beerAlcohol(r), nil
},
})
AddFuncLookup("beeribu", Info{
Display: "Beer IBU",
Category: "beer",
Description: "Scale measuring bitterness of beer from hops",
Example: "29 IBU",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return beerIbu(r), nil
},
})
AddFuncLookup("beerblg", Info{
Display: "Beer BLG",
Category: "beer",
Description: "Scale indicating the concentration of extract in worts",
Example: "6.4°Blg",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return beerBlg(r), nil
},
})
}

90
vendor/github.com/brianvoe/gofakeit/v6/book.go generated vendored Normal file
View File

@ -0,0 +1,90 @@
package gofakeit
import "math/rand"
func BookTitle() string { return bookTitle(globalFaker.Rand) }
func (f *Faker) BookTitle() string { return bookTitle(f.Rand) }
func bookTitle(r *rand.Rand) string { return getRandValue(r, []string{"book", "title"}) }
func BookAuthor() string { return bookAuthor(globalFaker.Rand) }
func (f *Faker) BookAuthor() string { return bookAuthor(f.Rand) }
func bookAuthor(r *rand.Rand) string { return getRandValue(r, []string{"book", "author"}) }
func BookGenre() string { return bookGenre(globalFaker.Rand) }
func (f *Faker) BookGenre() string { return bookGenre(f.Rand) }
func bookGenre(r *rand.Rand) string { return getRandValue(r, []string{"book", "genre"}) }
type BookInfo struct {
Title string `json:"title" xml:"name"`
Author string `json:"author" xml:"author"`
Genre string `json:"genre" xml:"genre"`
}
func Book() *BookInfo { return book(globalFaker.Rand) }
func (f *Faker) Book() *BookInfo { return book(f.Rand) }
func book(r *rand.Rand) *BookInfo {
return &BookInfo{
Title: bookTitle(r),
Author: bookAuthor(r),
Genre: bookGenre(r),
}
}
func addBookLookup() {
AddFuncLookup("book", Info{
Display: "Book",
Category: "book",
Description: "Written or printed work consisting of pages bound together, covering various subjects or stories",
Example: `{
"title": "Anna Karenina",
"author": "Toni Morrison",
"genre": "Thriller"
}`,
Output: "map[string]string",
ContentType: "application/json",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return book(r), nil
},
})
AddFuncLookup("booktitle", Info{
Display: "Title",
Category: "book",
Description: "The specific name given to a book",
Example: "Hamlet",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return bookTitle(r), nil
},
})
AddFuncLookup("bookauthor", Info{
Display: "Author",
Category: "book",
Description: "The individual who wrote or created the content of a book",
Example: "Mark Twain",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return bookAuthor(r), nil
},
})
AddFuncLookup("bookgenre", Info{
Display: "Genre",
Category: "book",
Description: "Category or type of book defined by its content, style, or form",
Example: "Adventure",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return bookGenre(r), nil
},
})
}

148
vendor/github.com/brianvoe/gofakeit/v6/car.go generated vendored Normal file
View File

@ -0,0 +1,148 @@
package gofakeit
import "math/rand"
// CarInfo is a struct dataset of all car information
type CarInfo struct {
Type string `json:"type" xml:"type"`
Fuel string `json:"fuel" xml:"fuel"`
Transmission string `json:"transmission" xml:"transmission"`
Brand string `json:"brand" xml:"brand"`
Model string `json:"model" xml:"model"`
Year int `json:"year" xml:"year"`
}
// Car will generate a struct with car information
func Car() *CarInfo { return car(globalFaker.Rand) }
// Car will generate a struct with car information
func (f *Faker) Car() *CarInfo { return car(f.Rand) }
func car(r *rand.Rand) *CarInfo {
return &CarInfo{
Type: carType(r),
Fuel: carFuelType(r),
Transmission: carTransmissionType(r),
Brand: carMaker(r),
Model: carModel(r),
Year: year(r),
}
}
// CarType will generate a random car type string
func CarType() string { return carType(globalFaker.Rand) }
// CarType will generate a random car type string
func (f *Faker) CarType() string { return carType(f.Rand) }
func carType(r *rand.Rand) string { return getRandValue(r, []string{"car", "type"}) }
// CarFuelType will return a random fuel type
func CarFuelType() string { return carFuelType(globalFaker.Rand) }
// CarFuelType will return a random fuel type
func (f *Faker) CarFuelType() string { return carFuelType(f.Rand) }
func carFuelType(r *rand.Rand) string { return getRandValue(r, []string{"car", "fuel_type"}) }
// CarTransmissionType will return a random transmission type
func CarTransmissionType() string { return carTransmissionType(globalFaker.Rand) }
// CarTransmissionType will return a random transmission type
func (f *Faker) CarTransmissionType() string { return carTransmissionType(f.Rand) }
func carTransmissionType(r *rand.Rand) string {
return getRandValue(r, []string{"car", "transmission_type"})
}
// CarMaker will return a random car maker
func CarMaker() string { return carMaker(globalFaker.Rand) }
// CarMaker will return a random car maker
func (f *Faker) CarMaker() string { return carMaker(f.Rand) }
func carMaker(r *rand.Rand) string { return getRandValue(r, []string{"car", "maker"}) }
// CarModel will return a random car model
func CarModel() string { return carModel(globalFaker.Rand) }
// CarModel will return a random car model
func (f *Faker) CarModel() string { return carModel(f.Rand) }
func carModel(r *rand.Rand) string { return getRandValue(r, []string{"car", "model"}) }
func addCarLookup() {
AddFuncLookup("car", Info{
Display: "Car",
Category: "car",
Description: "Wheeled motor vehicle used for transportation",
Example: `{
"type": "Passenger car mini",
"fuel": "Gasoline",
"transmission": "Automatic",
"brand": "Fiat",
"model": "Freestyle Fwd",
"year": 1991
}`,
Output: "map[string]any",
ContentType: "application/json",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return car(r), nil
},
})
AddFuncLookup("cartype", Info{
Display: "Car Type",
Category: "car",
Description: "Classification of cars based on size, use, or body style",
Example: "Passenger car mini",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return carType(r), nil
},
})
AddFuncLookup("carfueltype", Info{
Display: "Car Fuel Type",
Category: "car",
Description: "Type of energy source a car uses",
Example: "CNG",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return carFuelType(r), nil
},
})
AddFuncLookup("cartransmissiontype", Info{
Display: "Car Transmission Type",
Category: "car",
Description: "Mechanism a car uses to transmit power from the engine to the wheels",
Example: "Manual",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return carTransmissionType(r), nil
},
})
AddFuncLookup("carmaker", Info{
Display: "Car Maker",
Category: "car",
Description: "Company or brand that manufactures and designs cars",
Example: "Nissan",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return carMaker(r), nil
},
})
AddFuncLookup("carmodel", Info{
Display: "Car Model",
Category: "car",
Description: "Specific design or version of a car produced by a manufacturer",
Example: "Aveo",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return carModel(r), nil
},
})
}

64
vendor/github.com/brianvoe/gofakeit/v6/celebrity.go generated vendored Normal file
View File

@ -0,0 +1,64 @@
package gofakeit
import "math/rand"
// CelebrityActor will generate a random celebrity actor
func CelebrityActor() string { return celebrityActor(globalFaker.Rand) }
// CelebrityActor will generate a random celebrity actor
func (f *Faker) CelebrityActor() string { return celebrityActor(f.Rand) }
func celebrityActor(r *rand.Rand) string { return getRandValue(r, []string{"celebrity", "actor"}) }
// CelebrityBusiness will generate a random celebrity business person
func CelebrityBusiness() string { return celebrityBusiness(globalFaker.Rand) }
// CelebrityBusiness will generate a random celebrity business person
func (f *Faker) CelebrityBusiness() string { return celebrityBusiness(f.Rand) }
func celebrityBusiness(r *rand.Rand) string {
return getRandValue(r, []string{"celebrity", "business"})
}
// CelebritySport will generate a random celebrity sport person
func CelebritySport() string { return celebritySport(globalFaker.Rand) }
// CelebritySport will generate a random celebrity sport person
func (f *Faker) CelebritySport() string { return celebritySport(f.Rand) }
func celebritySport(r *rand.Rand) string { return getRandValue(r, []string{"celebrity", "sport"}) }
func addCelebrityLookup() {
AddFuncLookup("celebrityactor", Info{
Display: "Celebrity Actor",
Category: "celebrity",
Description: "Famous person known for acting in films, television, or theater",
Example: "Brad Pitt",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return celebrityActor(r), nil
},
})
AddFuncLookup("celebritybusiness", Info{
Display: "Celebrity Business",
Category: "celebrity",
Description: "High-profile individual known for significant achievements in business or entrepreneurship",
Example: "Elon Musk",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return celebrityBusiness(r), nil
},
})
AddFuncLookup("celebritysport", Info{
Display: "Celebrity Sport",
Category: "celebrity",
Description: "Famous athlete known for achievements in a particular sport",
Example: "Michael Phelps",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return celebritySport(r), nil
},
})
}

118
vendor/github.com/brianvoe/gofakeit/v6/color.go generated vendored Normal file
View File

@ -0,0 +1,118 @@
package gofakeit
import (
"math/rand"
"github.com/brianvoe/gofakeit/v6/data"
)
// Color will generate a random color string
func Color() string { return color(globalFaker.Rand) }
// Color will generate a random color string
func (f *Faker) Color() string { return color(f.Rand) }
func color(r *rand.Rand) string { return getRandValue(r, []string{"color", "full"}) }
// NiceColor will generate a random safe color string
func NiceColors() []string { return niceColors(globalFaker.Rand) }
// NiceColor will generate a random safe color string
func (f *Faker) NiceColors() []string { return niceColors(f.Rand) }
func niceColors(r *rand.Rand) []string {
return data.ColorsNice[randIntRange(r, 0, len(data.ColorsNice)-1)]
}
// SafeColor will generate a random safe color string
func SafeColor() string { return safeColor(globalFaker.Rand) }
// SafeColor will generate a random safe color string
func (f *Faker) SafeColor() string { return safeColor(f.Rand) }
func safeColor(r *rand.Rand) string { return getRandValue(r, []string{"color", "safe"}) }
// HexColor will generate a random hexadecimal color string
func HexColor() string { return hexColor(globalFaker.Rand) }
// HexColor will generate a random hexadecimal color string
func (f *Faker) HexColor() string { return hexColor(f.Rand) }
func hexColor(r *rand.Rand) string {
color := make([]byte, 6)
hashQuestion := []byte("?#")
for i := 0; i < 6; i++ {
color[i] = hashQuestion[r.Intn(2)]
}
return "#" + replaceWithHexLetters(r, replaceWithNumbers(r, string(color)))
}
// RGBColor will generate a random int slice color
func RGBColor() []int { return rgbColor(globalFaker.Rand) }
// RGBColor will generate a random int slice color
func (f *Faker) RGBColor() []int { return rgbColor(f.Rand) }
func rgbColor(r *rand.Rand) []int {
return []int{randIntRange(r, 0, 255), randIntRange(r, 0, 255), randIntRange(r, 0, 255)}
}
func addColorLookup() {
AddFuncLookup("color", Info{
Display: "Color",
Category: "color",
Description: "Hue seen by the eye, returns the name of the color like red or blue",
Example: "MediumOrchid",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return color(r), nil
},
})
AddFuncLookup("nicecolors", Info{
Display: "Nice Colors",
Category: "color",
Description: "Attractive and appealing combinations of colors, returns an list of color hex codes",
Example: `["#cfffdd","#b4dec1","#5c5863","#a85163","#ff1f4c"]`,
Output: "[]string",
ContentType: "application/json",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return color(r), nil
},
})
AddFuncLookup("safecolor", Info{
Display: "Safe Color",
Category: "color",
Description: "Colors displayed consistently on different web browsers and devices",
Example: "black",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return safeColor(r), nil
},
})
AddFuncLookup("hexcolor", Info{
Display: "Hex Color",
Category: "color",
Description: "Six-digit code representing a color in the color model",
Example: "#a99fb4",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return hexColor(r), nil
},
})
AddFuncLookup("rgbcolor", Info{
Display: "RGB Color",
Category: "color",
Description: "Color defined by red, green, and blue light values",
Example: "[85, 224, 195]",
Output: "[]int",
ContentType: "application/json",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return rgbColor(r), nil
},
})
}

231
vendor/github.com/brianvoe/gofakeit/v6/company.go generated vendored Normal file
View File

@ -0,0 +1,231 @@
package gofakeit
import "math/rand"
// Company will generate a random company name string
func Company() string { return company(globalFaker.Rand) }
// Company will generate a random company name string
func (f *Faker) Company() string { return company(f.Rand) }
func company(r *rand.Rand) string { return getRandValue(r, []string{"company", "name"}) }
// CompanySuffix will generate a random company suffix string
func CompanySuffix() string { return companySuffix(globalFaker.Rand) }
// CompanySuffix will generate a random company suffix string
func (f *Faker) CompanySuffix() string { return companySuffix(f.Rand) }
func companySuffix(r *rand.Rand) string { return getRandValue(r, []string{"company", "suffix"}) }
// Blurb will generate a random company blurb string
func Blurb() string { return blurb(globalFaker.Rand) }
func (f *Faker) Blurb() string { return blurb(f.Rand) }
func blurb(r *rand.Rand) string { return getRandValue(r, []string{"company", "blurb"}) }
// BuzzWord will generate a random company buzz word string
func BuzzWord() string { return buzzWord(globalFaker.Rand) }
// BuzzWord will generate a random company buzz word string
func (f *Faker) BuzzWord() string { return buzzWord(f.Rand) }
func buzzWord(r *rand.Rand) string { return getRandValue(r, []string{"company", "buzzwords"}) }
// BS will generate a random company bs string
func BS() string { return bs(globalFaker.Rand) }
// BS will generate a random company bs string
func (f *Faker) BS() string { return bs(f.Rand) }
func bs(r *rand.Rand) string { return getRandValue(r, []string{"company", "bs"}) }
// JobInfo is a struct of job information
type JobInfo struct {
Company string `json:"company" xml:"company"`
Title string `json:"title" xml:"title"`
Descriptor string `json:"descriptor" xml:"descriptor"`
Level string `json:"level" xml:"level"`
}
// Job will generate a struct with random job information
func Job() *JobInfo { return job(globalFaker.Rand) }
// Job will generate a struct with random job information
func (f *Faker) Job() *JobInfo { return job(f.Rand) }
func job(r *rand.Rand) *JobInfo {
return &JobInfo{
Company: company(r),
Title: jobTitle(r),
Descriptor: jobDescriptor(r),
Level: jobLevel(r),
}
}
// JobTitle will generate a random job title string
func JobTitle() string { return jobTitle(globalFaker.Rand) }
// JobTitle will generate a random job title string
func (f *Faker) JobTitle() string { return jobTitle(f.Rand) }
func jobTitle(r *rand.Rand) string { return getRandValue(r, []string{"job", "title"}) }
// JobDescriptor will generate a random job descriptor string
func JobDescriptor() string { return jobDescriptor(globalFaker.Rand) }
// JobDescriptor will generate a random job descriptor string
func (f *Faker) JobDescriptor() string { return jobDescriptor(f.Rand) }
func jobDescriptor(r *rand.Rand) string { return getRandValue(r, []string{"job", "descriptor"}) }
// JobLevel will generate a random job level string
func JobLevel() string { return jobLevel(globalFaker.Rand) }
// JobLevel will generate a random job level string
func (f *Faker) JobLevel() string { return jobLevel(f.Rand) }
func jobLevel(r *rand.Rand) string { return getRandValue(r, []string{"job", "level"}) }
// Slogan will generate a random company slogan
func Slogan() string { return slogan(globalFaker.Rand) }
// Slogan will generate a random company slogan
func (f *Faker) Slogan() string { return slogan(f.Rand) }
// Slogan will generate a random company slogan
func slogan(r *rand.Rand) string {
slogan := ""
var sloganStyle = number(r, 0, 2)
switch sloganStyle {
// Noun. Buzzword!
case 0:
slogan = getRandValue(r, []string{"company", "blurb"}) + ". " + getRandValue(r, []string{"company", "buzzwords"}) + "!"
// Buzzword Noun, Buzzword Noun.
case 1:
slogan = getRandValue(r, []string{"company", "buzzwords"}) + " " + getRandValue(r, []string{"company", "blurb"}) + ", " + getRandValue(r, []string{"company", "buzzwords"}) + " " + getRandValue(r, []string{"company", "blurb"}) + "."
// Buzzword bs Noun, Buzzword.
case 2:
slogan = getRandValue(r, []string{"company", "buzzwords"}) + " " + getRandValue(r, []string{"company", "bs"}) + " " + getRandValue(r, []string{"company", "blurb"}) + ", " + getRandValue(r, []string{"company", "buzzwords"}) + "."
}
return slogan
}
func addCompanyLookup() {
AddFuncLookup("company", Info{
Display: "Company",
Category: "company",
Description: "Designated official name of a business or organization",
Example: "Moen, Pagac and Wuckert",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return company(r), nil
},
})
AddFuncLookup("companysuffix", Info{
Display: "Company Suffix",
Category: "company",
Description: "Suffix at the end of a company name, indicating business structure, like 'Inc.' or 'LLC'",
Example: "Inc",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return companySuffix(r), nil
},
})
AddFuncLookup("bs", Info{
Display: "BS",
Category: "company",
Description: "Random bs company word",
Example: "front-end",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return bs(r), nil
},
})
AddFuncLookup("blurb", Info{
Display: "Blurb",
Category: "company",
Description: "Brief description or summary of a company's purpose, products, or services",
Example: "word",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return blurb(r), nil
},
})
AddFuncLookup("buzzword", Info{
Display: "Buzzword",
Category: "company",
Description: "Trendy or overused term often used in business to sound impressive",
Example: "disintermediate",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return buzzWord(r), nil
},
})
AddFuncLookup("job", Info{
Display: "Job",
Category: "company",
Description: "Position or role in employment, involving specific tasks and responsibilities",
Example: `{
"company": "ClearHealthCosts",
"title": "Agent",
"descriptor": "Future",
"level": "Tactics"
}`,
Output: "map[string]string",
ContentType: "application/json",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return job(r), nil
},
})
AddFuncLookup("jobtitle", Info{
Display: "Job Title",
Category: "company",
Description: "Specific title for a position or role within a company or organization",
Example: "Director",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return jobTitle(r), nil
},
})
AddFuncLookup("jobdescriptor", Info{
Display: "Job Descriptor",
Category: "company",
Description: "Word used to describe the duties, requirements, and nature of a job",
Example: "Central",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return jobDescriptor(r), nil
},
})
AddFuncLookup("joblevel", Info{
Display: "Job Level",
Category: "company",
Description: "Random job level",
Example: "Assurance",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return jobLevel(r), nil
},
})
AddFuncLookup("slogan", Info{
Display: "Slogan",
Category: "company",
Description: "Catchphrase or motto used by a company to represent its brand or values",
Example: "Universal seamless Focus, interactive.",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return slogan(r), nil
},
})
}

185
vendor/github.com/brianvoe/gofakeit/v6/csv.go generated vendored Normal file
View File

@ -0,0 +1,185 @@
package gofakeit
import (
"bytes"
"encoding/csv"
"encoding/json"
"errors"
"fmt"
"math/rand"
"reflect"
"strings"
)
// CSVOptions defines values needed for csv generation
type CSVOptions struct {
Delimiter string `json:"delimiter" xml:"delimiter" fake:"{randomstring:[,,tab]}"`
RowCount int `json:"row_count" xml:"row_count" fake:"{number:1,10}"`
Fields []Field `json:"fields" xml:"fields" fake:"{fields}"`
}
// CSV generates an object or an array of objects in json format
// A nil CSVOptions returns a randomly structured CSV.
func CSV(co *CSVOptions) ([]byte, error) { return csvFunc(globalFaker, co) }
// CSV generates an object or an array of objects in json format
// A nil CSVOptions returns a randomly structured CSV.
func (f *Faker) CSV(co *CSVOptions) ([]byte, error) { return csvFunc(f, co) }
func csvFunc(f *Faker, co *CSVOptions) ([]byte, error) {
if co == nil {
// We didn't get a CSVOptions, so create a new random one
err := f.Struct(&co)
if err != nil {
return nil, err
}
}
// Check delimiter
if co.Delimiter == "" {
co.Delimiter = ","
}
if strings.ToLower(co.Delimiter) == "tab" {
co.Delimiter = "\t"
}
if co.Delimiter != "," && co.Delimiter != "\t" && co.Delimiter != ";" {
return nil, errors.New("invalid delimiter type")
}
// Check fields
if co.Fields == nil || len(co.Fields) <= 0 {
return nil, errors.New("must pass fields in order to build json object(s)")
}
// Make sure you set a row count
if co.RowCount <= 0 {
return nil, errors.New("must have row count")
}
b := &bytes.Buffer{}
w := csv.NewWriter(b)
w.Comma = []rune(co.Delimiter)[0]
// Add header row
header := make([]string, len(co.Fields))
for i, field := range co.Fields {
header[i] = field.Name
}
w.Write(header)
// Loop through row count +1(for header) and add fields
for i := 1; i < co.RowCount+1; i++ {
vr := make([]string, len(co.Fields))
// Loop through fields and add to them to map[string]any
for ii, field := range co.Fields {
if field.Function == "autoincrement" {
vr[ii] = fmt.Sprintf("%d", i)
continue
}
// Get function info
funcInfo := GetFuncLookup(field.Function)
if funcInfo == nil {
return nil, errors.New("invalid function, " + field.Function + " does not exist")
}
value, err := funcInfo.Generate(f.Rand, &field.Params, funcInfo)
if err != nil {
return nil, err
}
if _, ok := value.([]byte); ok {
// If it's a slice of bytes or struct, unmarshal it into an interface
var v any
if err := json.Unmarshal(value.([]byte), &v); err != nil {
return nil, err
}
value = v
}
// If the value is a list of possible values, marsha it into a string
if reflect.TypeOf(value).Kind() == reflect.Struct ||
reflect.TypeOf(value).Kind() == reflect.Ptr ||
reflect.TypeOf(value).Kind() == reflect.Map ||
reflect.TypeOf(value).Kind() == reflect.Slice {
b, err := json.Marshal(value)
if err != nil {
return nil, err
}
value = string(b)
}
vr[ii] = fmt.Sprintf("%v", value)
}
w.Write(vr)
}
w.Flush()
if err := w.Error(); err != nil {
return nil, err
}
return b.Bytes(), nil
}
func addFileCSVLookup() {
AddFuncLookup("csv", Info{
Display: "CSV",
Category: "file",
Description: "Individual lines or data entries within a CSV (Comma-Separated Values) format",
Example: `id,first_name,last_name,password
1,Markus,Moen,Dc0VYXjkWABx
2,Osborne,Hilll,XPJ9OVNbs5lm`,
Output: "[]byte",
ContentType: "text/csv",
Params: []Param{
{Field: "delimiter", Display: "Delimiter", Type: "string", Default: ",", Description: "Separator in between row values"},
{Field: "rowcount", Display: "Row Count", Type: "int", Default: "100", Description: "Number of rows"},
{Field: "fields", Display: "Fields", Type: "[]Field", Description: "Fields containing key name and function"},
},
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
co := CSVOptions{}
delimiter, err := info.GetString(m, "delimiter")
if err != nil {
return nil, err
}
co.Delimiter = delimiter
rowcount, err := info.GetInt(m, "rowcount")
if err != nil {
return nil, err
}
co.RowCount = rowcount
fieldsStr, err := info.GetStringArray(m, "fields")
if err != nil {
return nil, err
}
// Check to make sure fields has length
if len(fieldsStr) > 0 {
co.Fields = make([]Field, len(fieldsStr))
for i, f := range fieldsStr {
// Unmarshal fields string into fields array
err = json.Unmarshal([]byte(f), &co.Fields[i])
if err != nil {
return nil, err
}
}
}
f := &Faker{Rand: r}
csvOut, err := csvFunc(f, &co)
if err != nil {
return nil, err
}
return csvOut, nil
},
})
}

33
vendor/github.com/brianvoe/gofakeit/v6/data/README.md generated vendored Normal file
View File

@ -0,0 +1,33 @@
# Gofakeit Data
Gofakeit data set
## List
```go
List()
```
## Get/Set/Remove Data
```go
data.Get("desserts")
data.Set("desserts", map[string][]string{
"cake": {"chocolate", "vanilla"},
"pie": {"apple", "pecan"},
"ice cream": {"strawberry", "vanilla"},
})
data.Remove("desserts")
```
## Get/Set/Remove Sub Data
```go
data.GetSubData("desserts", "cake")
data.SetSub("desserts", "cake", []string{"chocolate", "vanilla"})
data.RemoveSub("desserts", "cake")
```

15
vendor/github.com/brianvoe/gofakeit/v6/data/address.go generated vendored Normal file
View File

@ -0,0 +1,15 @@
package data
// Address consists of address information
var Address = map[string][]string{
"number": {"#####", "####", "###"},
"street_prefix": {"North", "East", "West", "South", "New", "Lake", "Port"},
"street_name": {"Alley", "Avenue", "Branch", "Bridge", "Brook", "Brooks", "Burg", "Burgs", "Bypass", "Camp", "Canyon", "Cape", "Causeway", "Center", "Centers", "Circle", "Circles", "Cliff", "Cliffs", "Club", "Common", "Corner", "Corners", "Course", "Court", "Courts", "Cove", "Coves", "Creek", "Crescent", "Crest", "Crossing", "Crossroad", "Curve", "Dale", "Dam", "Divide", "Drive", "Drive", "Drives", "Estate", "Estates", "Expressway", "Extension", "Extensions", "Fall", "Falls", "Ferry", "Field", "Fields", "Flat", "Flats", "Ford", "Fords", "Forest", "Forge", "Forges", "Fork", "Forks", "Fort", "Freeway", "Garden", "Gardens", "Gateway", "Glen", "Glens", "Green", "Greens", "Grove", "Groves", "Harbor", "Harbors", "Haven", "Heights", "Highway", "Hill", "Hills", "Hollow", "Inlet", "Inlet", "Island", "Island", "Islands", "Islands", "Isle", "Isle", "Junction", "Junctions", "Key", "Keys", "Knoll", "Knolls", "Lake", "Lakes", "Land", "Landing", "Lane", "Light", "Lights", "Loaf", "Lock", "Locks", "Locks", "Lodge", "Lodge", "Loop", "Mall", "Manor", "Manors", "Meadow", "Meadows", "Mews", "Mill", "Mills", "Mission", "Mission", "Motorway", "Mount", "Mountain", "Mountain", "Mountains", "Mountains", "Neck", "Orchard", "Oval", "Overpass", "Park", "Parks", "Parkway", "Parkways", "Pass", "Passage", "Path", "Pike", "Pine", "Pines", "Place", "Plain", "Plains", "Plains", "Plaza", "Plaza", "Point", "Points", "Port", "Port", "Ports", "Ports", "Prairie", "Prairie", "Radial", "Ramp", "Ranch", "Rapid", "Rapids", "Rest", "Ridge", "Ridges", "River", "Road", "Road", "Roads", "Roads", "Route", "Row", "Rue", "Run", "Shoal", "Shoals", "Shore", "Shores", "Skyway", "Spring", "Springs", "Springs", "Spur", "Spurs", "Square", "Square", "Squares", "Squares", "Station", "Station", "Stravenue", "Stravenue", "Stream", "Stream", "Street", "Street", "Streets", "Summit", "Summit", "Terrace", "Throughway", "Trace", "Track", "Trafficway", "Trail", "Trail", "Tunnel", "Tunnel", "Turnpike", "Turnpike", "Underpass", "Union", "Unions", "Valley", "Valleys", "Via", "Viaduct", "View", "Views", "Village", "Village", "Villages", "Ville", "Vista", "Vista", "Walk", "Walks", "Wall", "Way", "Ways", "Well", "Wells"},
"street_suffix": {"town", "ton", "land", "ville", "berg", "burgh", "borough", "bury", "view", "port", "mouth", "stad", "furt", "chester", "mouth", "fort", "haven", "side", "shire"},
"city": {"New York City", "Los Angeles", "Chicago", "Houston", "Philadelphia", "Phoenix", "San Antonio", "San Diego", "Dallas", "San Jose", "Austin", "Jacksonville", "Indianapolis", "San Francisco", "Columbus", "Fort Worth", "Charlotte", "Detroit", "El Paso", "Memphis", "Boston", "Seattle", "Denver", "Washington", "Nashville-Davidson", "Baltimore", "Louisville/Jefferson", "Portland", "Oklahoma", "Milwaukee", "Las Vegas", "Albuquerque", "Tucson", "Fresno", "Sacramento", "Long Beach", "Kansas", "Mesa", "Virginia Beach", "Atlanta", "Colorado Springs", "Raleigh", "Omaha", "Miami", "Oakland", "Tulsa", "Minneapolis", "Cleveland", "Wichita", "Arlington", "New Orleans", "Bakersfield", "Tampa", "Honolulu", "Anaheim", "Aurora", "Santa Ana", "St. Louis", "Riverside", "Corpus Christi", "Pittsburgh", "Lexington-Fayette", "Stockton", "Cincinnati", "St. Paul", "Toledo", "Newark", "Greensboro", "Plano", "Henderson", "Lincoln", "Buffalo", "Fort Wayne", "Jersey", "Chula Vista", "Orlando", "St. Petersburg", "Norfolk", "Chandler", "Laredo", "Madison", "Durham", "Lubbock", "Winston-Salem", "Garland", "Glendale", "Hialeah", "Reno", "Baton Rouge", "Irvine", "Chesapeake", "Irving", "Scottsdale", "North Las Vegas", "Fremont", "San Bernardino", "Boise", "Birmingham"},
"state": {"Alabama", "Alaska", "Arizona", "Arkansas", "California", "Colorado", "Connecticut", "Delaware", "Florida", "Georgia", "Hawaii", "Idaho", "Illinois", "Indiana", "Iowa", "Kansas", "Kentucky", "Louisiana", "Maine", "Maryland", "Massachusetts", "Michigan", "Minnesota", "Mississippi", "Missouri", "Montana", "Nebraska", "Nevada", "New Hampshire", "New Jersey", "New Mexico", "New York", "North Carolina", "North Dakota", "Ohio", "Oklahoma", "Oregon", "Pennsylvania", "Rhode Island", "South Carolina", "South Dakota", "Tennessee", "Texas", "Utah", "Vermont", "Virginia", "Washington", "West Virginia", "Wisconsin", "Wyoming"},
"state_abr": {"AL", "AK", "AZ", "AR", "CA", "CO", "CT", "DE", "FL", "GA", "HI", "ID", "IL", "IN", "IA", "KS", "KY", "LA", "ME", "MD", "MA", "MI", "MN", "MS", "MO", "MT", "NE", "NV", "NH", "NJ", "NM", "NY", "NC", "ND", "OH", "OK", "OR", "PA", "RI", "SC", "SD", "TN", "TX", "UT", "VT", "VA", "WA", "WV", "WI", "WY", "AE", "AA", "AP"},
"zip": {"#####"},
"country": {"Andorra", "United Arab Emirates", "Afghanistan", "Antigua and Barbuda", "Anguilla", "Albania", "Armenia", "Angola", "Antarctica", "Argentina", "American Samoa", "Austria", "Australia", "Aruba", "Åland Islands", "Azerbaijan", "Bosnia and Herzegovina", "Barbados", "Bangladesh", "Belgium", "Burkina Faso", "Bulgaria", "Bahrain", "Burundi", "Benin", "Saint Barthélemy", "Bermuda", "Brunei Darussalam", "Bolivia (Plurinational State of)", "Bonaire, Sint Eustatius and Saba", "Brazil", "Bahamas", "Bhutan", "Bouvet Island", "Botswana", "Belarus", "Belize", "Canada", "Cocos (Keeling) Islands", "Congo, Democratic Republic of the", "Central African Republic", "Congo", "Switzerland", "Côte d'Ivoire", "Cook Islands", "Chile", "Cameroon", "China", "Colombia", "Costa Rica", "Cuba", "Cabo Verde", "Curaçao", "Christmas Island", "Cyprus", "Czechia", "Germany", "Djibouti", "Denmark", "Dominica", "Dominican Republic", "Algeria", "Ecuador", "Estonia", "Egypt", "Western Sahara", "Eritrea", "Spain", "Ethiopia", "Finland", "Fiji", "Falkland Islands (Malvinas)", "Micronesia (Federated States of)", "Faroe Islands", "France", "Gabon", "United Kingdom of Great Britain and Northern Ireland", "Grenada", "Georgia", "French Guiana", "Guernsey", "Ghana", "Gibraltar", "Greenland", "Gambia", "Guinea", "Guadeloupe", "Equatorial Guinea", "Greece", "South Georgia and the South Sandwich Islands", "Guatemala", "Guam", "Guinea-Bissau", "Guyana", "Hong Kong", "Heard Island and McDonald Islands", "Honduras", "Croatia", "Haiti", "Hungary", "Indonesia", "Ireland", "Israel", "Isle of Man", "India", "British Indian Ocean Territory", "Iraq", "Iran (Islamic Republic of)", "Iceland", "Italy", "Jersey", "Jamaica", "Jordan", "Japan", "Kenya", "Kyrgyzstan", "Cambodia", "Kiribati", "Comoros", "Saint Kitts and Nevis", "Korea (Democratic People's Republic of)", "Korea, Republic of", "Kuwait", "Cayman Islands", "Kazakhstan", "Lao People's Democratic Republic", "Lebanon", "Saint Lucia", "Liechtenstein", "Sri Lanka", "Liberia", "Lesotho", "Lithuania", "Luxembourg", "Latvia", "Libya", "Morocco", "Monaco", "Moldova, Republic of", "Montenegro", "Saint Martin (French part)", "Madagascar", "Marshall Islands", "North Macedonia", "Mali", "Myanmar", "Mongolia", "Macao", "Northern Mariana Islands", "Martinique", "Mauritania", "Montserrat", "Malta", "Mauritius", "Maldives", "Malawi", "Mexico", "Malaysia", "Mozambique", "Namibia", "New Caledonia", "Niger", "Norfolk Island", "Nigeria", "Nicaragua", "Netherlands", "Norway", "Nepal", "Nauru", "Niue", "New Zealand", "Oman", "Panama", "Peru", "French Polynesia", "Papua New Guinea", "Philippines", "Pakistan", "Poland", "Saint Pierre and Miquelon", "Pitcairn", "Puerto Rico", "Palestine, State of", "Portugal", "Palau", "Paraguay", "Qatar", "Réunion", "Romania", "Serbia", "Russian Federation", "Rwanda", "Saudi Arabia", "Solomon Islands", "Seychelles", "Sudan", "Sweden", "Singapore", "Saint Helena, Ascension and Tristan da Cunha", "Slovenia", "Svalbard and Jan Mayen", "Slovakia", "Sierra Leone", "San Marino", "Senegal", "Somalia", "Suriname", "South Sudan", "Sao Tome and Principe", "El Salvador", "Sint Maarten (Dutch part)", "Syrian Arab Republic", "Eswatini", "Turks and Caicos Islands", "Chad", "French Southern Territories", "Togo", "Thailand", "Tajikistan", "Tokelau", "Timor-Leste", "Turkmenistan", "Tunisia", "Tonga", "Turkey", "Trinidad and Tobago", "Tuvalu", "Taiwan, Province of China", "Tanzania, United Republic of", "Ukraine", "Uganda", "United States Minor Outlying Islands", "United States of America", "Uruguay", "Uzbekistan", "Holy See", "Saint Vincent and the Grenadines", "Venezuela (Bolivarian Republic of)", "Virgin Islands (British)", "Virgin Islands (U.S.)", "Viet Nam", "Vanuatu", "Wallis and Futuna", "Samoa", "Yemen", "Mayotte", "South Africa", "Zambia", "Zimbabwe"},
"country_abr": {"AD", "AE", "AF", "AG", "AI", "AL", "AM", "AO", "AQ", "AR", "AS", "AT", "AU", "AW", "AX", "AZ", "BA", "BB", "BD", "BE", "BF", "BG", "BH", "BI", "BJ", "BL", "BM", "BN", "BO", "BQ", "BR", "BS", "BT", "BV", "BW", "BY", "BZ", "CA", "CC", "CD", "CF", "CG", "CH", "CI", "CK", "CL", "CM", "CN", "CO", "CR", "CU", "CV", "CW", "CX", "CY", "CZ", "DE", "DJ", "DK", "DM", "DO", "DZ", "EC", "EE", "EG", "EH", "ER", "ES", "ET", "FI", "FJ", "FK", "FM", "FO", "FR", "GA", "GB", "GD", "GE", "GF", "GG", "GH", "GI", "GL", "GM", "GN", "GP", "GQ", "GR", "GS", "GT", "GU", "GW", "GY", "HK", "HM", "HN", "HR", "HT", "HU", "ID", "IE", "IL", "IM", "IN", "IO", "IQ", "IR", "IS", "IT", "JE", "JM", "JO", "JP", "KE", "KG", "KH", "KI", "KM", "KN", "KP", "KR", "KW", "KY", "KZ", "LA", "LB", "LC", "LI", "LK", "LR", "LS", "LT", "LU", "LV", "LY", "MA", "MC", "MD", "ME", "MF", "MG", "MH", "MK", "ML", "MM", "MN", "MO", "MP", "MQ", "MR", "MS", "MT", "MU", "MV", "MW", "MX", "MY", "MZ", "NA", "NC", "NE", "NF", "NG", "NI", "NL", "NO", "NP", "NR", "NU", "NZ", "OM", "PA", "PE", "PF", "PG", "PH", "PK", "PL", "PM", "PN", "PR", "PS", "PT", "PW", "PY", "QA", "RE", "RO", "RS", "RU", "RW", "SA", "SB", "SC", "SD", "SE", "SG", "SH", "SI", "SJ", "SK", "SL", "SM", "SN", "SO", "SR", "SS", "ST", "SV", "SX", "SY", "SZ", "TC", "TD", "TF", "TG", "TH", "TJ", "TK", "TL", "TM", "TN", "TO", "TR", "TT", "TV", "TW", "TZ", "UA", "UG", "UM", "US", "UY", "UZ", "VA", "VC", "VE", "VG", "VI", "VN", "VU", "WF", "WS", "YE", "YT", "ZA", "ZM", "ZW"},
}

12
vendor/github.com/brianvoe/gofakeit/v6/data/animals.go generated vendored Normal file
View File

@ -0,0 +1,12 @@
package data
// Animal consists of animal information
var Animal = map[string][]string{
"petname": {"Alfalfa", "Archie", "Attila", "Baloo", "Bark Twain", "Barney", "Beans", "Bernadette", "Betty", "Binx", "Biscuit", "Bitsy", "Bob", "Bruiser", "Butterball", "Butters", "Chalupa", "Cheeseburger", "Chewbarka", "Chompers", "Cujo", "Demi", "Dobby", "Doc McDoggins", "Droolius Caesar", "Elmo", "Fergus", "Fluffernutter", "Franz Fur-dinand", "Frodo", "Fyodor Dogstoevsky", "Gary", "Gollum", "Hairy Paw-ter", "Hercules", "Hobbit", "Jabba", "Jellybean", "Jimmy Chew", "Kareem Abdul Ja-Bark", "Kevin", "Khaleesi", "Larry", "Lloyd", "Mary Puppins", "Matilda", "Meatball", "Mister Miyagi", "Moose", "Munchkin", "Nacho", "Noodles", "Nugget", "Olga", "Orville Redenbarker", "Ozzy Pawsborne", "Pam", "Peanut", "Pee Wee", "Pikachu", "Prince of Barkness", "Pumba", "Rambo", "Rex", "Rocky", "Rufus", "Salsa", "Salvador Dogi", "Santa Paws", "Sarah Jessica Barker", "Scrappy", "Sherlock Bones", "Squeakers", "Squirt", "Tank", "Tater", "The Notorious D.O.G.", "Toto", "Twinkie", "Waffles", "Waldo", "Winnie the Poodle", "Woofgang Puck", "Yoda", "Zeus"},
"animal": {"alligator", "alpaca", "ant", "antelope", "ape", "armadillo", "baboon", "badger", "bat", "bear", "beaver", "bee", "beetle", "buffalo", "butterfly", "camel", "caribou", "cat", "cattle", "cheetah", "chimpanzee", "chinchilla", "cicada", "clam", "cockroach", "cod", "coyote", "crab", "cricket", "crocodile", "crow", "deer", "dinosaur", "dog", "dolphin", "donkey", "duck", "eagle", "eel", "elephant", "elk", "ferret", "fish", "fly", "fox", "frog", "gerbil", "giraffe", "gnat", "gnu", "goat", "goldfish", "goose", "gorilla", "grasshopper", "guinea pig", "hamster", "hare", "hedgehog", "herring", "hippopotamus", "hornet", "horse", "hound", "hyena", "impala", "jackal", "jellyfish", "kangaroo", "koala", "leopard", "lion", "lizard", "llama", "locust", "louse", "macaw", "mallard", "mammoth", "manatee", "marten", "mink", "minnow", "mole", "monkey", "moose", "mosquito", "mouse", "mule", "muskrat", "otter", "ox", "oyster", "panda", "pig", "platypus", "porcupine", "porpoise", "prairie dog", "pug", "rabbit", "raccoon", "rat", "raven", "reindeer", "rhinoceros", "salmon", "sardine", "scorpion", "sea lion", "seal", "serval", "shark", "sheep", "skunk", "snail", "snake", "spider", "squirrel", "swan", "termite", "tiger", "toad", "tortoise", "trout", "turtle", "wallaby", "walrus", "wasp", "water buffalo", "weasel", "whale", "wildebeest", "wolf", "wombat", "woodchuck", "worm", "yak", "yellowjacket", "zebra"},
"type": {"amphibians", "birds", "fish", "invertebrates", "mammals", "reptiles"},
"farm": {"Chicken", "Cow", "Donkey", "Duck", "Goat", "Goose", "Horse", "Llama", "Pig", "Sheep", "Turkey"},
"cat": {"Abyssinian", "Aegean", "American Bobtail", "American Curl", "American Shorthair", "American Wirehair", "Arabian Mau", "Asian", "Asian Semi-longhair", "Australian Mist", "Balinese", "Bambino", "Bengal", "Birman", "Bombay", "Brazilian Shorthair", "British Longhair", "British Semipi-longhair", "British Shorthair", "Burmese", "Burmilla", "California Spangled", "Chantilly-Tiffany", "Chartreux", "Chausie", "Cheetoh", "Colorpoint Shorthair", "Cornish Rex", "Cymric, or Manx Longhair", "Cyprus", "Devon Rex", "Donskoy, or Don Sphynx", "Dragon Li", "Dwarf cat, or Dwelf", "Egyptian Mau", "European Shorthair", "Exotic Shorthair", "Foldex Cat", "German Rex", "Havana Brown", "Highlander", "Himalayan, or Colorpoint Persian", "Japanese Bobtail", "Javanese", "Khao Manee", "Korat", "Korean Bobtail", "Korn Ja", "Kurilian Bobtail", "Kurilian Bobtail, or Kuril Islands Bobtail", "LaPerm", "Lykoi", "Maine Coon", "Manx", "Mekong Bobtail", "Minskin", "Munchkin", "Napoleon", "Nebelung", "Norwegian Forest Cat", "Ocicat", "Ojos Azules", "Oregon Rex", "Oriental Bicolor", "Oriental Longhair", "Oriental Shorthair", "Persian", "Peterbald", "Pixie-bob", "Raas", "Ragamuffin", "Ragdoll", "Russian Blue", "Russian White, Black and Tabby", "Sam Sawet", "Savannah", "Scottish Fold", "Selkirk Rex", "Serengeti", "Serrade petit", "Siamese", "Siberian", "Singapura", "Snowshoe", "Sokoke", "Somali", "Sphynx", "Suphalak", "Thai", "Tonkinese", "Toyger", "Turkish Angora", "Turkish Van", "Ukrainian Levkoy"},
"dog": {"Affenpinscher", "African", "Airedale", "Akita", "Appenzeller", "Basenji", "Beagle", "Bluetick", "Borzoi", "Bouvier", "Boxer", "Brabancon", "Briard", "Boston Bulldog", "French Bulldog", "Staffordshire Bullterrier", "Cairn", "Chihuahua", "Chow", "Clumber", "Border Collie", "Coonhound", "Cardigan Corgi", "Dachshund", "Great Dane", "Scottish Deerhound", "Dhole", "Dingo", "Doberman", "Norwegian Elkhound", "Entlebucher", "Eskimo", "Germanshepherd", "Italian Greyhound", "Groenendael", "Ibizan Hound", "Afghan Hound", "Basset Hound", "Blood Hound", "English Hound", "Walker Hound", "Husky", "Keeshond", "Kelpie", "Komondor", "Kuvasz", "Labrador", "Leonberg", "Lhasa", "Malamute", "Malinois", "Maltese", "Bull Mastiff", "Tibetan Mastiff", "Mexicanhairless", "Bernese Mountain", "Swiss Mountain", "Newfoundland", "Otterhound", "Papillon", "Pekinese", "Pembroke", "Miniature Pinscher", "German Pointer", "Pomeranian", "Miniature Poodle", "Standard Poodle", "Toy Poodle", "Pug", "Pyrenees", "Redbone", "Chesapeake Retriever", "Curly Retriever", "Flatcoated Retriever", "Golden Retriever", "Rhodesian Ridgeback", "Rottweiler", "Saluki", "Samoyed", "Schipperke", "Giant Schnauzer", "Miniature Schnauzer", "English Setter", "Gordon Setter", "Irish Setter", "English Sheepdog", "Shetland Sheepdog", "Shiba", "Shihtzu", "Blenheim Spaniel", "Brittany Spaniel", "Cocker Spaniel", "Irish Spaniel", "Japanese Spaniel", "Sussex Spaniel", "Welsh Spaniel", "English Springer", "Stbernard", "American Terrier", "Australian Terrier", "Bedlington Terrier", "Border Terrier", "Dandie Terrier", "Fox Terrier", "Irish Terrier", "Kerryblue Terrier", "Lakeland Terrier", "Norfolk Terrier", "Norwich Terrier", "Patterdale Terrier", "Rat Terrier", "Scottish Terrier", "Sealyham Terrier", "Silky Terrier", "Tibetan Terrier", "Toy Terrier", "Westhighland Terrier", "Wheaten Terrier", "Yorkshire Terrier", "Vizsla", "Weimaraner", "Whippet", "Irish Wolfhound"},
"bird": {"albatross", "bluejay", "canary", "cardinal", "chicken", "crow", "dove", "duck", "eagle", "emu", "falcon", "flamingo", "goose", "hornbill", "hummingbird", "ibis", "jay", "kingfisher", "lovebird", "mynah", "nightingale", "oriole", "ostrich", "owl", "parrot", "peacock", "penguin", "quail", "rooster", "sparrow", "swan", "thrush", "toucan", "vulture", "woodpecker", "yellow warbler"},
}

10
vendor/github.com/brianvoe/gofakeit/v6/data/beer.go generated vendored Normal file
View File

@ -0,0 +1,10 @@
package data
// Beer consists of various beer information
var Beer = map[string][]string{
"name": {"Pliny The Elder", "Founders Kentucky Breakfast", "Trappistes Rochefort 10", "HopSlam Ale", "Stone Imperial Russian Stout", "St. Bernardus Abt 12", "Founders Breakfast Stout", "Weihenstephaner Hefeweissbier", "Péché Mortel", "Celebrator Doppelbock", "Duvel", "Dreadnaught IPA", "Nugget Nectar", "La Fin Du Monde", "Bourbon County Stout", "Old Rasputin Russian Imperial Stout", "Two Hearted Ale", "Ruination IPA", "Schneider Aventinus", "Double Bastard Ale", "90 Minute IPA", "Hop Rod Rye", "Trappistes Rochefort 8", "Chimay Grande Réserve", "Stone IPA", "Arrogant Bastard Ale", "Edmund Fitzgerald Porter", "Chocolate St", "Oak Aged Yeti Imperial Stout", "Ten FIDY", "Storm King Stout", "Shakespeare Oatmeal", "Alpha King Pale Ale", "Westmalle Trappist Tripel", "Samuel Smith’s Imperial IPA", "Yeti Imperial Stout", "Hennepin", "Samuel Smith’s Oatmeal Stout", "Brooklyn Black", "Oaked Arrogant Bastard Ale", "Sublimely Self-Righteous Ale", "Trois Pistoles", "Bell’s Expedition", "Sierra Nevada Celebration Ale", "Sierra Nevada Bigfoot Barleywine Style Ale", "Racer 5 India Pale Ale, Bear Republic Bre", "Orval Trappist Ale", "Hercules Double IPA", "Maharaj", "Maudite"},
"hop": {"Ahtanum", "Amarillo", "Bitter Gold", "Bravo", "Brewer’s Gold", "Bullion", "Cascade", "Cashmere", "Centennial", "Chelan", "Chinook", "Citra", "Cluster", "Columbia", "Columbus", "Comet", "Crystal", "Equinox", "Eroica", "Fuggle", "Galena", "Glacier", "Golding", "Hallertau", "Horizon", "Liberty", "Magnum", "Millennium", "Mosaic", "Mt. Hood", "Mt. Rainier", "Newport", "Northern Brewer", "Nugget", "Olympic", "Palisade", "Perle", "Saaz", "Santiam", "Simcoe", "Sorachi Ace", "Sterling", "Summit", "Tahoma", "Tettnang", "TriplePearl", "Ultra", "Vanguard", "Warrior", "Willamette", "Yakima Gol"},
"yeast": {"1007 - German Ale", "1010 - American Wheat", "1028 - London Ale", "1056 - American Ale", "1084 - Irish Ale", "1098 - British Ale", "1099 - Whitbread Ale", "1187 - Ringwood Ale", "1272 - American Ale II", "1275 - Thames Valley Ale", "1318 - London Ale III", "1332 - Northwest Ale", "1335 - British Ale II", "1450 - Dennys Favorite 50", "1469 - West Yorkshire Ale", "1728 - Scottish Ale", "1968 - London ESB Ale", "2565 - Kölsch", "1214 - Belgian Abbey", "1388 - Belgian Strong Ale", "1762 - Belgian Abbey II", "3056 - Bavarian Wheat Blend", "3068 - Weihenstephan Weizen", "3278 - Belgian Lambic Blend", "3333 - German Wheat", "3463 - Forbidden Fruit", "3522 - Belgian Ardennes", "3638 - Bavarian Wheat", "3711 - French Saison", "3724 - Belgian Saison", "3763 - Roeselare Ale Blend", "3787 - Trappist High Gravity", "3942 - Belgian Wheat", "3944 - Belgian Witbier", "2000 - Budvar Lager", "2001 - Urquell Lager", "2007 - Pilsen Lager", "2035 - American Lager", "2042 - Danish Lager", "2112 - California Lager", "2124 - Bohemian Lager", "2206 - Bavarian Lager", "2278 - Czech Pils", "2308 - Munich Lager", "2633 - Octoberfest Lager Blend", "5112 - Brettanomyces bruxellensis", "5335 - Lactobacillus", "5526 - Brettanomyces lambicus", "5733 - Pediococcus"},
"malt": {"Black malt", "Caramel", "Carapils", "Chocolate", "Munich", "Caramel", "Carapils", "Chocolate malt", "Munich", "Pale", "Roasted barley", "Rye malt", "Special roast", "Victory", "Vienna", "Wheat mal"},
"style": {"Light Lager", "Pilsner", "European Amber Lager", "Dark Lager", "Bock", "Light Hybrid Beer", "Amber Hybrid Beer", "English Pale Ale", "Scottish And Irish Ale", "Merican Ale", "English Brown Ale", "Porter", "Stout", "India Pale Ale", "German Wheat And Rye Beer", "Belgian And French Ale", "Sour Ale", "Belgian Strong Ale", "Strong Ale", "Fruit Beer", "Vegetable Beer", "Smoke-flavored", "Wood-aged Beer"},
}

101
vendor/github.com/brianvoe/gofakeit/v6/data/book.go generated vendored Normal file
View File

@ -0,0 +1,101 @@
package data
var Books = map[string][]string{
"title": {
"Anna Karenina",
"Beloved",
"Blindness",
"Bostan",
"Buddenbrooks",
"Crime and Punishment",
"Don Quijote De La Mancha",
"Fairy tales",
"Faust",
"Gulliver's Travels",
"Gypsy Ballads",
"Hamlet",
"Harry potter and the sorcerer's stone",
"King Lear",
"Leaves of Grass",
"Lolita",
"Madame Bovary",
"Memoirs of Hadrian",
"Metamorphoses",
"Moby Dick",
"Nineteen Eighty-Four",
"Odyssey",
"Oedipus the King",
"One Hundred Years of Solitude",
"One Thousand and One Nights",
"Othello",
"Pippi Longstocking",
"Pride and Prejudice",
"Romeo & Juliet",
"Sherlock Holmes",
"Sons and Lovers",
"The Adventures of Huckleberry Finn",
"The Book Of Job",
"The Brothers Karamazov",
"The Golden Notebook",
"The Idiot",
"The Old Man and the Sea",
"The Stranger",
"Things Fall Apart",
"Ulysses",
"War and Peace",
"Wuthering Heights",
"Zorba the Greek",
},
"author": {
"Albert Camus",
"Astrid Lindgren",
"Charles Dickens",
"D. H. Lawrence",
"Edgar Allan Poe",
"Emily Brontë",
"Ernest Hemingway",
"Franz Kafka",
"Fyodor Dostoevsky",
"George Orwell",
"Hans Christian Andersen",
"Homer",
"James Joyce",
"Jane Austen",
"Johann Wolfgang von Goethe",
"Jorge Luis Borges",
"Joanne K. Rowling",
"Leo Tolstoy",
"Marcel Proust",
"Mark Twain",
"Paul Celan",
"Salman Rushdie",
"Sophocles",
"Thomas Mann",
"Toni Morrison",
"Vladimir Nabokov",
"William Faulkner",
"William Shakespeare",
"Yasunari Kawabata",
},
"genre": {
"Adventure",
"Comic",
"Crime",
"Erotic",
"Fiction",
"Fantasy",
"Historical",
"Horror",
"Magic",
"Mystery",
"Philosophical",
"Political",
"Romance",
"Saga",
"Satire",
"Science",
"Speculative",
"Thriller",
"Urban",
},
}

10
vendor/github.com/brianvoe/gofakeit/v6/data/car.go generated vendored Normal file
View File

File diff suppressed because one or more lines are too long

7
vendor/github.com/brianvoe/gofakeit/v6/data/celebrity.go generated vendored Normal file
View File

@ -0,0 +1,7 @@
package data
var Celebrity = map[string][]string{
"actor": {"Arnold Schwarzenegger", "Jim Carrey", "Emma Watson", "Robert Downey Jr.", "Daniel Radcliffe", "Chris Evans", "Leonardo DiCaprio", "Tom Cruise", "Brad Pitt", "Charles Chaplin", "Morgan Freeman", "Tom Hanks", "Hugh Jackman", "Matt Damon", "Sylvester Stallone", "Will Smith", "Clint Eastwood", "Cameron Diaz", "George Clooney", "Steven Spielberg", "Harrison Ford", "Robert De Niro", "Al Pacino", "Robert Downey Jr.", "Russell Crowe", "Liam Neeson", "Kate Winslet", "Mark Wahlberg", "Natalie Portman", "Pierce Brosnan", "Sean Connery", "Orlando Bloom", "Dwayne Johnson", "Jackie Chan", "Angelina Jolie", "Adam Sandler", "Scarlett Johansson", "Heath Ledger", "Anne Hathaway", "Jessica Alba", "Edward Norton", "Keira Knightley", "Bradley Cooper", "Will Ferrell", "Julia Roberts", "Nicolas Cage", "Daniel Craig", "Keanu Reeves", "Ian McKellen", "Halle Berry", "Bruce Willis", "Ben Stiller", "Tommy Lee Jones", "Antonio Banderas", "Denzel Washington", "Steve Carell", "Shia LaBeouf", "Megan Fox", "James Franco", "Mel Gibson", "Vin Diesel", "Tim Allen", "Robin Williams", "Kevin Spacey", "Jason Biggs", "Seann William Scott", "Jean-Claude Van Damme", "Zach Galifianakis", "Owen Wilson", "Christian Bale", "Peter Jackson", "Sandra Bullock", "Bruce Lee", "Drew Barrymore", "Macaulay Culkin", "Jack Nicholson", "Bill Murray", "Sigourney Weaver", "Jake Gyllenhaal", "Jason Statham", "Jet Li", "Kate Beckinsale", "Rowan Atkinson", "Marlon Brando", "John Travolta", "Channing Tatum", "Ben Affleck", "Shah Rukh Khan", "Jennifer Aniston", "Emma Stone", "Chris Hemsworth", "James McAvoy", "James Cameron", "Amitabh Bachchan", "Brendan Fraser", "Rachel McAdams", "Tom Hiddleston", "Aamir Khan"},
"business": {"Elon Musk", "Steve Jobs", "Jeff Bezos", "Bill Gates", "Mark Zuckerberg", "Sundar Pichai", "Walt Disney", "Warren Buffett", "Mukesh Ambani", "P. T. Barnum", "Colonel Sanders", "Ray Kroc", "Richard Branson", "Henry Ford", "Larry Page", "Steve Wozniak", "Ratan Tata", "John D. Rockefeller", "Madam C. J. Walker", "Tim Cook", "Andrew Carnegie", "Paul Allen", "Bobby Flay", "J. P. Morgan", "Satya Nadella", "Dhirubhai Ambani", "Carlos Slim", "Ross Perot", "Jamie Oliver", "Jack Ma", "Larry Ellison", "Sam Walton", "Sheryl Sandberg", "Marco Pierre White", "Indra Nooyi", "David Rockefeller", "Steve Ballmer", "Beyonce Knowles", "N. R. Narayana Murthy", "Mark Wahlberg", "Cameron Diaz", "Sergey Brin", "Howard Hughes", "Jessica Alba", "Dustin Moskovitz", "Eva Mendes", "Amancio Ortega Gaona", "Fred Trump", "Jamsetji Tata", "Kate Hudson", "Martha Stewart", "Peter Jones", "Marco Polo", "Susan Wojcicki", "Oskar Schindler", "Elizabeth Hurley", "Sean Combs", "Kate Spade", "Vincent McMahon", "David Chang", "Coco Chanel", "Vera Wang", "Arianna Huffington", "John McAfee", "Dany Garcia", "Richard Attenborough", "Donatella Versace", "Chris Hughes", "Alexis Ohanian", "J. Paul Getty", "Sharon Osbourne", "Bob Iger", "Kate Walsh", "Chris Gardner", "Jessica Simpson", "Guy Fieri", "Joy Mangano", "Wolfgang Puck", "Christie Brinkley", "Tom Steyer", "Evan Spiegel", "Hugh Hefner", "Preity Zinta", "Shane McMahon", "Salt Bae", "Mario Batali", "Bernard Arnault", "Michael Bloomberg", "Portia de Rossi", "Kevin O'Leary", "Roman Abramovich", "Jamie Dimon", "Rob Dyrdek", "Emeril Lagasse", "Kat Von D", "Karlie Kloss", "Antoni Porowski", "Edmond James de Rothschild", "Mitt Romney", "Aristotle Onassis", "Richard Benjamin Harrison", "Ben Bernanke", "Mark Cuban", "William Randolph Hearst", "Nate Robinson", "Alan Shepard", "Christina Anstead", "Laurene Powell Jobs", "Adam Weitsman", "Gladys Knight", "Gary Vaynerchuk", "Robert Kraft", "John Paul DeJoria", "Lori Greiner", "Carly Fiorina", "Lakshmi Mittal", "Jerry Jones", "Meg Whitman", "Azim Premji", "Lisa Vanderpump", "Dana White", "Russell Simmons", "Jennifer Flavin", "Harry Hamlin", "Conrad Hilton", "Prescott Bush", "Alvaro Morte", "Shigeru Miyamoto", "Phil Knight", "Jack Dorsey", "Barbara Bush", "Lee Iacocca", "Ma Huateng", "Rick Harrison", "Drew Scott", "Jawed Karim", "Daymond John", "Jaclyn Smith", "Maryse Ouellet", "Allegra Versace"},
"sport": {"Pele", "Usain Bolt", "Muhammad Ali", "Carl Lewis", "Jesse Owens", "Sir Donald Bradman", "Billie Jean King", "Eddy Merckx", "Jackie Joyner-Kersee", "Lionel Messi", "Babe Didrikson Zaharias", "Michael Jordan", "Larisa Latynina", "Diego Maradona", "Serena Williams", "Babe Ruth", "Roger Federer", "Martina Navratilova", "Michael Phelps", "Lottie Dod", "Sachin Tendulkar", "Johan Cruyff", "Tiger Woods", "Sonja Henie", "Aryton Senna", "Nadia Comaneci", "Sergei Bubka", "Emil Zatopek", "Manny Pacquiao", "Imran Khan", "Jackie Robinson", "Shane Warne", "Dhyan Chand", "Fred Perry", "Lin Dan", "Abebe Bikila", "Clara Hughes", "Jan-Ove Waldner", "Bobby Moore", "Bjorn Borg", "Karch Kiraly", "Bradley Wiggins", "Seve Ballesteros", "David Beckham", "Michael Schumacher", "Greg Lemond", "Mia Hamm", "Jacques Anquetil", "Jack Nicklaus", "Steve Davis", "John McEnroe", "Monica Seles", "Magic Johnson", "Joe DiMaggio", "Roger Bannister", "Mo Farah", "Mark Spitz", "Chris Evert", "Al Oerter", "Jimmy Connors", "Michael Johnson", "Ian Botham", "Jim Thorpe", "Sir Steve Redgrave", "Steffi Graf", "Sebastian Coe", "Hicham El Guerrouj", "Eric Liddell", "W.G Grace", "Kenenisa Bekele", "Bernard Hinault", "Bob Beamon", "Paavo Nurmi", "David Campese", "Kelly Slater", "Haile Gebreselassie", "Rafael Nadal", "Brian Lara", "Chris Hoy", "Serge Blanco", "Cristiano Ronaldo", "Sir Gary Sobers", "Andy Murray", "George Best", "Sir Viv Richards", "Fausto Coppi", "Eusebio", "Rod Laver", "Grete Waitz", "Margaret Smith Court", "Tegla Laroupe", "Fanny Blankers-Koen", "Asbel Kiprop", "Lewis Hamilton", "C.B.Fry", "Annika Sörenstam", "Wilma Rudolph", "Alberta Tomba", "Bo Jackson"},
}

110
vendor/github.com/brianvoe/gofakeit/v6/data/colors.go generated vendored Normal file
View File

@ -0,0 +1,110 @@
package data
// Colors consists of color information
var Colors = map[string][]string{
"safe": {"black", "maroon", "green", "navy", "olive", "purple", "teal", "lime", "blue", "silver", "gray", "yellow", "fuchsia", "aqua", "white"},
"full": {"AliceBlue", "AntiqueWhite", "Aqua", "Aquamarine", "Azure", "Beige", "Bisque", "Black", "BlanchedAlmond", "Blue", "BlueViolet", "Brown", "BurlyWood", "CadetBlue", "Chartreuse", "Chocolate", "Coral", "CornflowerBlue", "Cornsilk", "Crimson", "Cyan", "DarkBlue", "DarkCyan", "DarkGoldenRod", "DarkGray", "DarkGreen", "DarkKhaki", "DarkMagenta", "DarkOliveGreen", "Darkorange", "DarkOrchid", "DarkRed", "DarkSalmon", "DarkSeaGreen", "DarkSlateBlue", "DarkSlateGray", "DarkTurquoise", "DarkViolet", "DeepPink", "DeepSkyBlue", "DimGray", "DimGrey", "DodgerBlue", "FireBrick", "FloralWhite", "ForestGreen", "Fuchsia", "Gainsboro", "GhostWhite", "Gold", "GoldenRod", "Gray", "Green", "GreenYellow", "HoneyDew", "HotPink", "IndianRed", "Indigo", "Ivory", "Khaki", "Lavender", "LavenderBlush", "LawnGreen", "LemonChiffon", "LightBlue", "LightCoral", "LightCyan", "LightGoldenRodYellow", "LightGray", "LightGreen", "LightPink", "LightSalmon", "LightSeaGreen", "LightSkyBlue", "LightSlateGray", "LightSteelBlue", "LightYellow", "Lime", "LimeGreen", "Linen", "Magenta", "Maroon", "MediumAquaMarine", "MediumBlue", "MediumOrchid", "MediumPurple", "MediumSeaGreen", "MediumSlateBlue", "MediumSpringGreen", "MediumTurquoise", "MediumVioletRed", "MidnightBlue", "MintCream", "MistyRose", "Moccasin", "NavajoWhite", "Navy", "OldLace", "Olive", "OliveDrab", "Orange", "OrangeRed", "Orchid", "PaleGoldenRod", "PaleGreen", "PaleTurquoise", "PaleVioletRed", "PapayaWhip", "PeachPuff", "Peru", "Pink", "Plum", "PowderBlue", "Purple", "Red", "RosyBrown", "RoyalBlue", "SaddleBrown", "Salmon", "SandyBrown", "SeaGreen", "SeaShell", "Sienna", "Silver", "SkyBlue", "SlateBlue", "SlateGray", "Snow", "SpringGreen", "SteelBlue", "Tan", "Teal", "Thistle", "Tomato", "Turquoise", "Violet", "Wheat", "White", "WhiteSmoke", "Yellow", "YellowGreen"},
}
var ColorsNice = [][]string{
{"#69d2e7", "#a7dbd8", "#e0e4cc", "#f38630", "#fa6900"},
{"#fe4365", "#fc9d9a", "#f9cdad", "#c8c8a9", "#83af9b"},
{"#ecd078", "#d95b43", "#c02942", "#542437", "#53777a"},
{"#556270", "#4ecdc4", "#c7f464", "#ff6b6b", "#c44d58"},
{"#774f38", "#e08e79", "#f1d4af", "#ece5ce", "#c5e0dc"},
{"#e8ddcb", "#cdb380", "#036564", "#033649", "#031634"},
{"#490a3d", "#bd1550", "#e97f02", "#f8ca00", "#8a9b0f"},
{"#594f4f", "#547980", "#45ada8", "#9de0ad", "#e5fcc2"},
{"#00a0b0", "#6a4a3c", "#cc333f", "#eb6841", "#edc951"},
{"#e94e77", "#d68189", "#c6a49a", "#c6e5d9", "#f4ead5"},
{"#3fb8af", "#7fc7af", "#dad8a7", "#ff9e9d", "#ff3d7f"},
{"#d9ceb2", "#948c75", "#d5ded9", "#7a6a53", "#99b2b7"},
{"#ffffff", "#cbe86b", "#f2e9e1", "#1c140d", "#cbe86b"},
{"#efffcd", "#dce9be", "#555152", "#2e2633", "#99173c"},
{"#343838", "#005f6b", "#008c9e", "#00b4cc", "#00dffc"},
{"#413e4a", "#73626e", "#b38184", "#f0b49e", "#f7e4be"},
{"#ff4e50", "#fc913a", "#f9d423", "#ede574", "#e1f5c4"},
{"#99b898", "#fecea8", "#ff847c", "#e84a5f", "#2a363b"},
{"#655643", "#80bca3", "#f6f7bd", "#e6ac27", "#bf4d28"},
{"#00a8c6", "#40c0cb", "#f9f2e7", "#aee239", "#8fbe00"},
{"#351330", "#424254", "#64908a", "#e8caa4", "#cc2a41"},
{"#554236", "#f77825", "#d3ce3d", "#f1efa5", "#60b99a"},
{"#5d4157", "#838689", "#a8caba", "#cad7b2", "#ebe3aa"},
{"#8c2318", "#5e8c6a", "#88a65e", "#bfb35a", "#f2c45a"},
{"#fad089", "#ff9c5b", "#f5634a", "#ed303c", "#3b8183"},
{"#ff4242", "#f4fad2", "#d4ee5e", "#e1edb9", "#f0f2eb"},
{"#f8b195", "#f67280", "#c06c84", "#6c5b7b", "#355c7d"},
{"#d1e751", "#ffffff", "#000000", "#4dbce9", "#26ade4"},
{"#1b676b", "#519548", "#88c425", "#bef202", "#eafde6"},
{"#5e412f", "#fcebb6", "#78c0a8", "#f07818", "#f0a830"},
{"#bcbdac", "#cfbe27", "#f27435", "#f02475", "#3b2d38"},
{"#452632", "#91204d", "#e4844a", "#e8bf56", "#e2f7ce"},
{"#eee6ab", "#c5bc8e", "#696758", "#45484b", "#36393b"},
{"#f0d8a8", "#3d1c00", "#86b8b1", "#f2d694", "#fa2a00"},
{"#2a044a", "#0b2e59", "#0d6759", "#7ab317", "#a0c55f"},
{"#f04155", "#ff823a", "#f2f26f", "#fff7bd", "#95cfb7"},
{"#b9d7d9", "#668284", "#2a2829", "#493736", "#7b3b3b"},
{"#bbbb88", "#ccc68d", "#eedd99", "#eec290", "#eeaa88"},
{"#b3cc57", "#ecf081", "#ffbe40", "#ef746f", "#ab3e5b"},
{"#a3a948", "#edb92e", "#f85931", "#ce1836", "#009989"},
{"#300030", "#480048", "#601848", "#c04848", "#f07241"},
{"#67917a", "#170409", "#b8af03", "#ccbf82", "#e33258"},
{"#aab3ab", "#c4cbb7", "#ebefc9", "#eee0b7", "#e8caaf"},
{"#e8d5b7", "#0e2430", "#fc3a51", "#f5b349", "#e8d5b9"},
{"#ab526b", "#bca297", "#c5ceae", "#f0e2a4", "#f4ebc3"},
{"#607848", "#789048", "#c0d860", "#f0f0d8", "#604848"},
{"#b6d8c0", "#c8d9bf", "#dadabd", "#ecdbbc", "#fedcba"},
{"#a8e6ce", "#dcedc2", "#ffd3b5", "#ffaaa6", "#ff8c94"},
{"#3e4147", "#fffedf", "#dfba69", "#5a2e2e", "#2a2c31"},
{"#fc354c", "#29221f", "#13747d", "#0abfbc", "#fcf7c5"},
{"#cc0c39", "#e6781e", "#c8cf02", "#f8fcc1", "#1693a7"},
{"#1c2130", "#028f76", "#b3e099", "#ffeaad", "#d14334"},
{"#a7c5bd", "#e5ddcb", "#eb7b59", "#cf4647", "#524656"},
{"#dad6ca", "#1bb0ce", "#4f8699", "#6a5e72", "#563444"},
{"#5c323e", "#a82743", "#e15e32", "#c0d23e", "#e5f04c"},
{"#edebe6", "#d6e1c7", "#94c7b6", "#403b33", "#d3643b"},
{"#fdf1cc", "#c6d6b8", "#987f69", "#e3ad40", "#fcd036"},
{"#230f2b", "#f21d41", "#ebebbc", "#bce3c5", "#82b3ae"},
{"#b9d3b0", "#81bda4", "#b28774", "#f88f79", "#f6aa93"},
{"#3a111c", "#574951", "#83988e", "#bcdea5", "#e6f9bc"},
{"#5e3929", "#cd8c52", "#b7d1a3", "#dee8be", "#fcf7d3"},
{"#1c0113", "#6b0103", "#a30006", "#c21a01", "#f03c02"},
{"#000000", "#9f111b", "#b11623", "#292c37", "#cccccc"},
{"#382f32", "#ffeaf2", "#fcd9e5", "#fbc5d8", "#f1396d"},
{"#e3dfba", "#c8d6bf", "#93ccc6", "#6cbdb5", "#1a1f1e"},
{"#f6f6f6", "#e8e8e8", "#333333", "#990100", "#b90504"},
{"#1b325f", "#9cc4e4", "#e9f2f9", "#3a89c9", "#f26c4f"},
{"#a1dbb2", "#fee5ad", "#faca66", "#f7a541", "#f45d4c"},
{"#c1b398", "#605951", "#fbeec2", "#61a6ab", "#accec0"},
{"#5e9fa3", "#dcd1b4", "#fab87f", "#f87e7b", "#b05574"},
{"#951f2b", "#f5f4d7", "#e0dfb1", "#a5a36c", "#535233"},
{"#8dccad", "#988864", "#fea6a2", "#f9d6ac", "#ffe9af"},
{"#2d2d29", "#215a6d", "#3ca2a2", "#92c7a3", "#dfece6"},
{"#413d3d", "#040004", "#c8ff00", "#fa023c", "#4b000f"},
{"#eff3cd", "#b2d5ba", "#61ada0", "#248f8d", "#605063"},
{"#ffefd3", "#fffee4", "#d0ecea", "#9fd6d2", "#8b7a5e"},
{"#cfffdd", "#b4dec1", "#5c5863", "#a85163", "#ff1f4c"},
{"#9dc9ac", "#fffec7", "#f56218", "#ff9d2e", "#919167"},
{"#4e395d", "#827085", "#8ebe94", "#ccfc8e", "#dc5b3e"},
{"#a8a7a7", "#cc527a", "#e8175d", "#474747", "#363636"},
{"#f8edd1", "#d88a8a", "#474843", "#9d9d93", "#c5cfc6"},
{"#046d8b", "#309292", "#2fb8ac", "#93a42a", "#ecbe13"},
{"#f38a8a", "#55443d", "#a0cab5", "#cde9ca", "#f1edd0"},
{"#a70267", "#f10c49", "#fb6b41", "#f6d86b", "#339194"},
{"#ff003c", "#ff8a00", "#fabe28", "#88c100", "#00c176"},
{"#ffedbf", "#f7803c", "#f54828", "#2e0d23", "#f8e4c1"},
{"#4e4d4a", "#353432", "#94ba65", "#2790b0", "#2b4e72"},
{"#0ca5b0", "#4e3f30", "#fefeeb", "#f8f4e4", "#a5b3aa"},
{"#4d3b3b", "#de6262", "#ffb88c", "#ffd0b3", "#f5e0d3"},
{"#fffbb7", "#a6f6af", "#66b6ab", "#5b7c8d", "#4f2958"},
{"#edf6ee", "#d1c089", "#b3204d", "#412e28", "#151101"},
{"#9d7e79", "#ccac95", "#9a947c", "#748b83", "#5b756c"},
{"#fcfef5", "#e9ffe1", "#cdcfb7", "#d6e6c3", "#fafbe3"},
{"#9cddc8", "#bfd8ad", "#ddd9ab", "#f7af63", "#633d2e"},
{"#30261c", "#403831", "#36544f", "#1f5f61", "#0b8185"},
{"#aaff00", "#ffaa00", "#ff00aa", "#aa00ff", "#00aaff"},
{"#d1313d", "#e5625c", "#f9bf76", "#8eb2c5", "#615375"},
{"#ffe181", "#eee9e5", "#fad3b2", "#ffba7f", "#ff9c97"},
{"#73c8a9", "#dee1b6", "#e1b866", "#bd5532", "#373b44"},
{"#805841", "#dcf7f3", "#fffcdd", "#ffd8d8", "#f5a2a2"},
}

10
vendor/github.com/brianvoe/gofakeit/v6/data/company.go generated vendored Normal file
View File

File diff suppressed because one or more lines are too long

8
vendor/github.com/brianvoe/gofakeit/v6/data/computer.go generated vendored Normal file
View File

@ -0,0 +1,8 @@
package data
// Computer consists of computer information
var Computer = map[string][]string{
"linux_processor": {"i686", "x86_64"},
"mac_processor": {"Intel", "PPC", "U; Intel", "U; PPC"},
"windows_platform": {"Windows NT 6.2", "Windows NT 6.1", "Windows NT 6.0", "Windows NT 5.2", "Windows NT 5.1", "Windows NT 5.01", "Windows NT 5.0", "Windows NT 4.0", "Windows 98; Win 9x 4.90", "Windows 98", "Windows 95", "Windows CE"},
}

7
vendor/github.com/brianvoe/gofakeit/v6/data/currency.go generated vendored Normal file
View File

@ -0,0 +1,7 @@
package data
// Currency consists of currency information
var Currency = map[string][]string{
"short": {"AED", "AFN", "ALL", "AMD", "ANG", "AOA", "ARS", "AUD", "AWG", "AZN", "BAM", "BBD", "BDT", "BGN", "BHD", "BIF", "BMD", "BND", "BOB", "BRL", "BSD", "BTN", "BWP", "BYR", "BZD", "CAD", "CDF", "CHF", "CLP", "CNY", "COP", "CRC", "CUC", "CUP", "CVE", "CZK", "DJF", "DKK", "DOP", "DZD", "EGP", "ERN", "ETB", "EUR", "FJD", "FKP", "GBP", "GEL", "GGP", "GHS", "GIP", "GMD", "GNF", "GTQ", "GYD", "HKD", "HNL", "HRK", "HTG", "HUF", "IDR", "ILS", "IMP", "INR", "IQD", "IRR", "ISK", "JEP", "JMD", "JOD", "JPY", "KES", "KGS", "KHR", "KMF", "KPW", "KRW", "KWD", "KYD", "KZT", "LAK", "LBP", "LKR", "LRD", "LSL", "LTL", "LYD", "MAD", "MDL", "MGA", "MKD", "MMK", "MNT", "MOP", "MRO", "MUR", "MVR", "MWK", "MXN", "MYR", "MZN", "NAD", "NGN", "NIO", "NOK", "NPR", "NZD", "OMR", "PAB", "PEN", "PGK", "PHP", "PKR", "PLN", "PYG", "QAR", "RON", "RSD", "RUB", "RWF", "SAR", "SBD", "SCR", "SDG", "SEK", "SGD", "SHP", "SLL", "SOS", "SPL", "SRD", "STD", "SVC", "SYP", "SZL", "THB", "TJS", "TMT", "TND", "TOP", "TRY", "TTD", "TVD", "TWD", "TZS", "UAH", "UGX", "USD", "UYU", "UZS", "VEF", "VND", "VUV", "WST", "XAF", "XCD", "XDR", "XOF", "XPF", "YER", "ZAR", "ZMW", "ZWD"},
"long": {"United Arab Emirates Dirham", "Afghanistan Afghani", "Albania Lek", "Armenia Dram", "Netherlands Antilles Guilder", "Angola Kwanza", "Argentina Peso", "Australia Dollar", "Aruba Guilder", "Azerbaijan New Manat", "Bosnia and Herzegovina Convertible Marka", "Barbados Dollar", "Bangladesh Taka", "Bulgaria Lev", "Bahrain Dinar", "Burundi Franc", "Bermuda Dollar", "Brunei Darussalam Dollar", "Bolivia Boliviano", "Brazil Real", "Bahamas Dollar", "Bhutan Ngultrum", "Botswana Pula", "Belarus Ruble", "Belize Dollar", "Canada Dollar", "Congo/Kinshasa Franc", "Switzerland Franc", "Chile Peso", "China Yuan Renminbi", "Colombia Peso", "Costa Rica Colon", "Cuba Convertible Peso", "Cuba Peso", "Cape Verde Escudo", "Czech Republic Koruna", "Djibouti Franc", "Denmark Krone", "Dominican Republic Peso", "Algeria Dinar", "Egypt Pound", "Eritrea Nakfa", "Ethiopia Birr", "Euro Member Countries", "Fiji Dollar", "Falkland Islands (Malvinas) Pound", "United Kingdom Pound", "Georgia Lari", "Guernsey Pound", "Ghana Cedi", "Gibraltar Pound", "Gambia Dalasi", "Guinea Franc", "Guatemala Quetzal", "Guyana Dollar", "Hong Kong Dollar", "Honduras Lempira", "Croatia Kuna", "Haiti Gourde", "Hungary Forint", "Indonesia Rupiah", "Israel Shekel", "Isle of Man Pound", "India Rupee", "Iraq Dinar", "Iran Rial", "Iceland Krona", "Jersey Pound", "Jamaica Dollar", "Jordan Dinar", "Japan Yen", "Kenya Shilling", "Kyrgyzstan Som", "Cambodia Riel", "Comoros Franc", "Korea (North) Won", "Korea (South) Won", "Kuwait Dinar", "Cayman Islands Dollar", "Kazakhstan Tenge", "Laos Kip", "Lebanon Pound", "Sri Lanka Rupee", "Liberia Dollar", "Lesotho Loti", "Lithuania Litas", "Libya Dinar", "Morocco Dirham", "Moldova Leu", "Madagascar Ariary", "Macedonia Denar", "Myanmar (Burma) Kyat", "Mongolia Tughrik", "Macau Pataca", "Mauritania Ouguiya", "Mauritius Rupee", "Maldives (Maldive Islands) Rufiyaa", "Malawi Kwacha", "Mexico Peso", "Malaysia Ringgit", "Mozambique Metical", "Namibia Dollar", "Nigeria Naira", "Nicaragua Cordoba", "Norway Krone", "Nepal Rupee", "New Zealand Dollar", "Oman Rial", "Panama Balboa", "Peru Nuevo Sol", "Papua New Guinea Kina", "Philippines Peso", "Pakistan Rupee", "Poland Zloty", "Paraguay Guarani", "Qatar Riyal", "Romania New Leu", "Serbia Dinar", "Russia Ruble", "Rwanda Franc", "Saudi Arabia Riyal", "Solomon Islands Dollar", "Seychelles Rupee", "Sudan Pound", "Sweden Krona", "Singapore Dollar", "Saint Helena Pound", "Sierra Leone Leone", "Somalia Shilling", "Seborga Luigino", "Suriname Dollar", "São Tomé and Príncipe Dobra", "El Salvador Colon", "Syria Pound", "Swaziland Lilangeni", "Thailand Baht", "Tajikistan Somoni", "Turkmenistan Manat", "Tunisia Dinar", "Tonga Pa'anga", "Turkey Lira", "Trinidad and Tobago Dollar", "Tuvalu Dollar", "Taiwan New Dollar", "Tanzania Shilling", "Ukraine Hryvnia", "Uganda Shilling", "United States Dollar", "Uruguay Peso", "Uzbekistan Som", "Venezuela Bolivar", "Viet Nam Dong", "Vanuatu Vatu", "Samoa Tala", "Communauté Financière Africaine (BEAC) CFA Franc BEAC", "East Caribbean Dollar", "International Monetary Fund (IMF) Special Drawing Rights", "Communauté Financière Africaine (BCEAO) Franc", "Comptoirs Français du Pacifique (CFP) Franc", "Yemen Rial", "South Africa Rand", "Zambia Kwacha", "Zimbabwe Dollar"},
}

90
vendor/github.com/brianvoe/gofakeit/v6/data/data.go generated vendored Normal file
View File

@ -0,0 +1,90 @@
package data
// Data consists of the main set of fake information
var Data = map[string]map[string][]string{
"person": Person,
"address": Address,
"company": Company,
"job": Job,
"lorem": Lorem,
"language": Languages,
"internet": Internet,
"file": Files,
"color": Colors,
"computer": Computer,
"hipster": Hipster,
"beer": Beer,
"hacker": Hacker,
"animal": Animal,
"currency": Currency,
"log_level": LogLevels,
"timezone": TimeZone,
"car": Car,
"emoji": Emoji,
"word": Word,
"sentence": Sentence,
"food": Food,
"minecraft": Minecraft,
"celebrity": Celebrity,
"error": Error,
"html": Html,
"book": Books,
"movie": Movies,
"school": School,
"product": Product,
}
func List() map[string][]string {
var list = make(map[string][]string)
// Loop through the data and add the keys to the list
for key := range Data {
list[key] = []string{}
// Loop through the sub data and add the keys to the list
for subkey := range Data[key] {
list[key] = append(list[key], subkey)
}
}
return list
}
func Get(key string) map[string][]string {
// Make sure the key exists, if not return an empty map
if _, ok := Data[key]; !ok {
return make(map[string][]string)
}
return Data[key]
}
func Set(key string, data map[string][]string) {
Data[key] = data
}
func Remove(key string) {
delete(Data, key)
}
func GetSubData(key, subkey string) []string {
// Make sure the key exists, if not return an empty map
if _, ok := Data[key]; !ok {
return []string{}
}
return Data[key][subkey]
}
func SetSub(key, subkey string, data []string) {
// Make sure the key exists, if not add it
if _, ok := Data[key]; !ok {
Data[key] = make(map[string][]string)
}
Data[key][subkey] = data
}
func RemoveSub(key, subkey string) {
delete(Data[key], subkey)
}

10
vendor/github.com/brianvoe/gofakeit/v6/data/datetime.go generated vendored Normal file
View File

File diff suppressed because one or more lines are too long

5863
vendor/github.com/brianvoe/gofakeit/v6/data/emoji.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

122
vendor/github.com/brianvoe/gofakeit/v6/data/errors.go generated vendored Normal file
View File

@ -0,0 +1,122 @@
package data
var Error = map[string][]string{
"object": {
"argument",
"buffer",
"connection",
"database",
"header",
"hostname",
"method",
"object",
"parameter",
"pointer",
"port",
"protocol",
"request",
"response",
"server",
"service",
"signature",
"tag",
"undefined",
"url",
"uri",
"variable",
},
"generic": {
"error",
"syntax error",
"requested {errorobject} is unavailable",
"failed to {hackerverb} {errorobject}",
"expected {errorobject} is undefined",
"[object Object]",
"no such variable",
"{errorobject} not initialized",
"variable assigned before declaration",
},
"database": {
"sql error",
"database connection error",
"table does not exist",
"unique key constraint",
"table migration failed",
"bad connection",
"destination pointer is nil",
},
"grpc": {
"connection refused",
"connection closed",
"connection is shut down",
"client protocol error",
},
"http": {
"cross-origin-resource-policy error",
"feature not supported",
"trailer header without chunked transfer encoding",
"no multipart boundary param in Content-Type",
"request Content-Type isn't multipart/form-data",
"header too long",
"entity body too short",
"missing ContentLength in HEAD response",
"named cookie not present",
"invalid method",
"connection has been hijacked",
"request method or response status code does not allow body",
"wrote more than the declared Content-Length",
"{httpmethod} not allowed",
},
"http_client": { // 400s
"bad request", // 400
"unauthorized", // 401
"payment required", // 402
"forbidden", // 403
"not found", // 404
"method not allowed", // 405
"not acceptable", // 406
"proxy authentication required", // 407
"request timeout", // 408
"conflict", // 409
"gone", // 410
"length required", // 411
"precondition failed", // 412
"payload too large", // 413
"URI too long", // 414
"unsupported media type", // 415
"range not satisfiable", // 416
"expectation failed", // 417
"im a teapot", // 418
},
"http_server": { // 500s
"internal server error", // 500
"not implemented", // 501
"bad gateway", // 502
"service unavailable", // 503
"gateway timeout", // 504
"http version not supported", // 505
"variant also negotiates", // 506
"insufficient storage", // 507
"loop detected", // 508
"not extended", // 510
"network authentication required", // 511
},
"runtime": {
"panic: runtime error: invalid memory address or nil pointer dereference",
"address out of bounds",
"undefined has no such property 'length'",
"not enough arguments",
"expected 2 arguments, got 3",
},
"validation": {
"invalid format",
"missing required field",
"{inputname} is required",
"{inputname} max length exceeded",
"{inputname} must be at exactly 16 characters",
"{inputname} must be at exactly 32 bytes",
"failed to parse {inputname}",
"date is in the past",
"payment details cannot be verified",
},
}

7
vendor/github.com/brianvoe/gofakeit/v6/data/files.go generated vendored Normal file
View File

File diff suppressed because one or more lines are too long

13
vendor/github.com/brianvoe/gofakeit/v6/data/food.go generated vendored Normal file
View File

File diff suppressed because one or more lines are too long

20
vendor/github.com/brianvoe/gofakeit/v6/data/hacker.go generated vendored Normal file
View File

@ -0,0 +1,20 @@
package data
// Hacker consists of random hacker phrases
var Hacker = map[string][]string{
"abbreviation": {"TCP", "HTTP", "SDD", "RAM", "GB", "CSS", "SSL", "AGP", "SQL", "FTP", "PCI", "AI", "ADP", "RSS", "XML", "EXE", "COM", "HDD", "THX", "SMTP", "SMS", "USB", "PNG", "SAS", "IB", "SCSI", "JSON", "XSS", "JBOD"},
"adjective": {"auxiliary", "primary", "back-end", "digital", "open-source", "virtual", "cross-platform", "redundant", "online", "haptic", "multi-byte", "bluetooth", "wireless", "1080p", "neural", "optical", "solid state", "mobile"},
"noun": {"driver", "protocol", "bandwidth", "panel", "microchip", "program", "port", "card", "array", "interface", "system", "sensor", "firewall", "hard drive", "pixel", "alarm", "feed", "monitor", "application", "transmitter", "bus", "circuit", "capacitor", "matrix"},
"verb": {"back up", "bypass", "hack", "override", "compress", "copy", "navigate", "index", "connect", "generate", "quantify", "calculate", "synthesize", "input", "transmit", "program", "reboot", "parse", "read", "write", "load", "render", "validate", "verify", "sign", "decrypt", "encrypt", "construct", "deconstruct", "compile", "transpile", "bundle", "lock", "unlock", "buffer", "format"},
"ingverb": {"backing up", "bypassing", "hacking", "overriding", "compressing", "copying", "navigating", "indexing", "connecting", "generating", "quantifying", "calculating", "synthesizing", "transmitting", "programming", "parsing"},
"phrase": {
"If we {hackerverb} the {hackernoun}, we can get to the {hackerabbreviation} {hackernoun} through the {hackeradjective} {hackerabbreviation} {hackernoun}!",
"We need to {hackerverb} the {hackeradjective} {hackerabbreviation} {hackernoun}!",
"Try to {hackerverb} the {hackerabbreviation} {hackernoun}, maybe it will {hackerverb} the {hackeradjective} {hackernoun}!",
"You can't {hackerverb} the {hackernoun} without {hackeringverb} the {hackeradjective} {hackerabbreviation} {hackernoun}!",
"Use the {hackeradjective} {hackerabbreviation} {hackernoun}, then you can {hackerverb} the {hackeradjective} {hackernoun}!",
"The {hackerabbreviation} {hackernoun} is down, {hackerverb} the {hackeradjective} {hackernoun} so we can {hackerverb} the {hackerabbreviation} {hackernoun}!",
"{hackeringverb} the {hackernoun} won't do anything, we need to {hackerverb} the {hackeradjective} {hackerabbreviation} {hackernoun}!",
"I'll {hackerverb} the {hackeradjective} {hackerabbreviation} {hackernoun}, that should {hackerverb} the {hackerabbreviation} {hackernoun}!",
},
}

6
vendor/github.com/brianvoe/gofakeit/v6/data/hipster.go generated vendored Normal file
View File

@ -0,0 +1,6 @@
package data
// Hipster consists of random hipster words
var Hipster = map[string][]string{
"word": {"Wes Anderson", "chicharrones", "narwhal", "food truck", "marfa", "aesthetic", "keytar", "art party", "sustainable", "forage", "mlkshk", "gentrify", "locavore", "swag", "hoodie", "microdosing", "VHS", "before they sold out", "pabst", "plaid", "Thundercats", "freegan", "scenester", "hella", "occupy", "truffaut", "raw denim", "beard", "post-ironic", "photo booth", "twee", "90's", "pitchfork", "cray", "cornhole", "kale chips", "pour-over", "yr", "five dollar toast", "kombucha", "you probably haven't heard of them", "mustache", "fixie", "try-hard", "franzen", "kitsch", "austin", "stumptown", "keffiyeh", "whatever", "tumblr", "DIY", "shoreditch", "biodiesel", "vegan", "pop-up", "banjo", "kogi", "cold-pressed", "letterpress", "chambray", "butcher", "synth", "trust fund", "hammock", "farm-to-table", "intelligentsia", "loko", "ugh", "offal", "poutine", "gastropub", "Godard", "jean shorts", "sriracha", "dreamcatcher", "leggings", "fashion axe", "church-key", "meggings", "tote bag", "disrupt", "readymade", "helvetica", "flannel", "meh", "roof", "hashtag", "knausgaard", "cronut", "schlitz", "green juice", "waistcoat", "normcore", "viral", "ethical", "actually", "fingerstache", "humblebrag", "deep v", "wayfarers", "tacos", "taxidermy", "selvage", "put a bird on it", "ramps", "portland", "retro", "kickstarter", "bushwick", "brunch", "distillery", "migas", "flexitarian", "XOXO", "small batch", "messenger bag", "heirloom", "tofu", "bicycle rights", "bespoke", "salvia", "wolf", "selfies", "echo", "park", "listicle", "craft beer", "chartreuse", "sartorial", "pinterest", "mumblecore", "kinfolk", "vinyl", "etsy", "umami", "8-bit", "polaroid", "banh mi", "crucifix", "bitters", "brooklyn", "PBR&B", "drinking", "vinegar", "squid", "tattooed", "skateboard", "vice", "authentic", "literally", "lomo", "celiac", "health", "goth", "artisan", "chillwave", "blue bottle", "pickled", "next level", "neutra", "organic", "Yuccie", "paleo", "blog", "single-origin coffee", "seitan", "street", "gluten-free", "mixtape", "venmo", "irony", "everyday", "carry", "slow-carb", "3 wolf moon", "direct trade", "lo-fi", "tousled", "tilde", "semiotics", "cred", "chia", "master", "cleanse", "ennui", "quinoa", "pug", "iPhone", "fanny pack", "cliche", "cardigan", "asymmetrical", "meditation", "YOLO", "typewriter", "pork belly", "shabby chic", "+1", "lumbersexual", "williamsburg"},
}

7
vendor/github.com/brianvoe/gofakeit/v6/data/html.go generated vendored Normal file
View File

@ -0,0 +1,7 @@
package data
// Html consists of various html information
var Html = map[string][]string{
"svg": {"rect", "circle", "ellipse", "line", "polyline", "polygon"},
"input_name": {"title", "first_name", "last_name", "suffix", "address", "postal_code", "city", "state", "country", "date_of_birth", "card_number", "description", "message", "status"},
}

11
vendor/github.com/brianvoe/gofakeit/v6/data/internet.go generated vendored Normal file
View File

@ -0,0 +1,11 @@
package data
// Internet consists of various internet information
var Internet = map[string][]string{
"browser": {"firefox", "chrome", "internetExplorer", "opera", "safari"},
"domain_suffix": {"com", "biz", "info", "name", "net", "org", "io"},
"http_method": {"HEAD", "GET", "POST", "PUT", "PATCH", "DELETE"},
"http_version": {"HTTP/1.0", "HTTP/1.1", "HTTP/2.0"},
"http_status_simple": {"200", "301", "302", "400", "404", "500"},
"http_status_general": {"100", "200", "201", "203", "204", "205", "301", "302", "304", "400", "401", "403", "404", "405", "406", "416", "500", "501", "502", "503", "504"},
}

8
vendor/github.com/brianvoe/gofakeit/v6/data/job.go generated vendored Normal file
View File

@ -0,0 +1,8 @@
package data
// Job consists of job data
var Job = map[string][]string{
"title": {"Administrator", "Agent", "Analyst", "Architect", "Assistant", "Associate", "Consultant", "Coordinator", "Designer", "Developer", "Director", "Engineer", "Executive", "Facilitator", "Liaison", "Manager", "Officer", "Orchestrator", "Planner", "Producer", "Representative", "Specialist", "Strategist", "Supervisor", "Technician"},
"descriptor": {"Central", "Chief", "Corporate", "Customer", "Direct", "District", "Dynamic", "Dynamic", "Forward", "Future", "Global", "Human", "Internal", "International", "Investor", "Lead", "Legacy", "National", "Principal", "Product", "Regional", "Senior"},
"level": {"Accountability", "Accounts", "Applications", "Assurance", "Brand", "Branding", "Communications", "Configuration", "Creative", "Data", "Directives", "Division", "Factors", "Functionality", "Group", "Identity", "Implementation", "Infrastructure", "Integration", "Interactions", "Intranet", "Marketing", "Markets", "Metrics", "Mobility", "Operations", "Optimization", "Paradigm", "Program", "Quality", "Research", "Response", "Security", "Solutions", "Tactics", "Usability", "Web"},
}

9
vendor/github.com/brianvoe/gofakeit/v6/data/languages.go generated vendored Normal file
View File

File diff suppressed because one or more lines are too long

8
vendor/github.com/brianvoe/gofakeit/v6/data/log_level.go generated vendored Normal file
View File

@ -0,0 +1,8 @@
package data
// LogLevels consists of log levels for several types
var LogLevels = map[string][]string{
"general": {"error", "warning", "info", "fatal", "trace", "debug"},
"syslog": {"emerg", "alert", "crit", "err", "warning", "notice", "info", "debug"},
"apache": {"emerg", "alert", "crit", "error", "warn", "notice", "info", "debug", "trace1-8"},
}

6
vendor/github.com/brianvoe/gofakeit/v6/data/lorem.go generated vendored Normal file
View File

@ -0,0 +1,6 @@
package data
// Lorem consists of lorem ipsum information
var Lorem = map[string][]string{
"word": {"alias", "consequatur", "aut", "perferendis", "sit", "voluptatem", "accusantium", "doloremque", "aperiam", "eaque", "ipsa", "quae", "ab", "illo", "inventore", "veritatis", "et", "quasi", "architecto", "beatae", "vitae", "dicta", "sunt", "explicabo", "aspernatur", "aut", "odit", "aut", "fugit", "sed", "quia", "consequuntur", "magni", "dolores", "eos", "qui", "ratione", "voluptatem", "sequi", "nesciunt", "neque", "dolorem", "ipsum", "quia", "dolor", "sit", "amet", "consectetur", "adipisci", "velit", "sed", "quia", "non", "numquam", "eius", "modi", "tempora", "incidunt", "ut", "labore", "et", "dolore", "magnam", "aliquam", "quaerat", "voluptatem", "ut", "enim", "ad", "minima", "veniam", "quis", "nostrum", "exercitationem", "ullam", "corporis", "nemo", "enim", "ipsam", "voluptatem", "quia", "voluptas", "sit", "suscipit", "laboriosam", "nisi", "ut", "aliquid", "ex", "ea", "commodi", "consequatur", "quis", "autem", "vel", "eum", "iure", "reprehenderit", "qui", "in", "ea", "voluptate", "velit", "esse", "quam", "nihil", "molestiae", "et", "iusto", "odio", "dignissimos", "ducimus", "qui", "blanditiis", "praesentium", "laudantium", "totam", "rem", "voluptatum", "deleniti", "atque", "corrupti", "quos", "dolores", "et", "quas", "molestias", "excepturi", "sint", "occaecati", "cupiditate", "non", "provident", "sed", "ut", "perspiciatis", "unde", "omnis", "iste", "natus", "error", "similique", "sunt", "in", "culpa", "qui", "officia", "deserunt", "mollitia", "animi", "id", "est", "laborum", "et", "dolorum", "fuga", "et", "harum", "quidem", "rerum", "facilis", "est", "et", "expedita", "distinctio", "nam", "libero", "tempore", "cum", "soluta", "nobis", "est", "eligendi", "optio", "cumque", "nihil", "impedit", "quo", "porro", "quisquam", "est", "qui", "minus", "id", "quod", "maxime", "placeat", "facere", "possimus", "omnis", "voluptas", "assumenda", "est", "omnis", "dolor", "repellendus", "temporibus", "autem", "quibusdam", "et", "aut", "consequatur", "vel", "illum", "qui", "dolorem", "eum", "fugiat", "quo", "voluptas", "nulla", "pariatur", "at", "vero", "eos", "et", "accusamus", "officiis", "debitis", "aut", "rerum", "necessitatibus", "saepe", "eveniet", "ut", "et", "voluptates", "repudiandae", "sint", "et", "molestiae", "non", "recusandae", "itaque", "earum", "rerum", "hic", "tenetur", "a", "sapiente", "delectus", "ut", "aut", "reiciendis", "voluptatibus", "maiores", "doloribus", "asperiores", "repellat"},
}

23
vendor/github.com/brianvoe/gofakeit/v6/data/minecraft.go generated vendored Normal file
View File

@ -0,0 +1,23 @@
package data
// Minecraft consists of various minecraft items
var Minecraft = map[string][]string{
"ore": {"coal", "copper", "iron", "gold", "redstone", "lapis", "diamond", "emerald"},
"wood": {"oak", "spruce", "birch", "jungle", "acacia", "dark oak"},
"armortier": {"leather", "chainmail", "iron", "gold", "diamond", "netherite"},
"armorpart": {"helmet", "chestplate", "leggings", "boots"},
"weapon": {"sword", "bow", "arrow", "trident", "shield"},
"tool": {"pickaxe", "axe", "shovel", "hoe", "fishing rod"},
"dye": {"white", "orange", "magenta", "light blue", "yellow", "lime", "pink", "gray", "light gray", "cyan", "purple", "blue", "brown", "green", "red", "black"},
"food": {"apple", "baked potato", "beetroot", "beetroot soup", "bread", "cake", "carrot", "chorus fruit", "cooked chicken", "cooked cod", "cooked mutton", "cooked salmon", "cookie", "enchanted golden apple", "golden apple", "glow berry", "golden carrot", "honey bottle", "melon slice", "mushroom stew", "poisonous potato", "potato", "pufferfish", "pumpkin pie", "rabbit stew", "raw beef", "raw chicken", "raw cod", "raw mutton", "raw porkchop", "raw rabbit", "raw salmon", "rotten flesh", "spider eye", "steak", "suspicous stew", "sweet berry", "tropical fish"},
"animal": {"chicken", "cow", "pig", "rabbit", "sheep", "wolf"},
"villagerjob": {"armourer", "butcher", "carpenter", "cleric", "farmer", "fisherman", "fletcher", "leatherworker", "librarian", "mason", "nitwit", "shepherd", "toolsmith", "weaponsmith"},
"villagerstation": {"composter", "smoker", "barrel", "loom", "blast furnace", "brewing stand", "cauldron", "fletching table", "cartography table", "lectern", "smithing table", "stonecutter", "grindstone"},
"villagerlevel": {"novice", "apprentice", "journeyman", "expert", "master"},
"mobpassive": {"axolotl", "bat", "cat", "chicken", "cod", "cow", "donkey", "fox", "glow squid", "horse", "mooshroom", "mule", "ocelot", "parrot", "pig", "pufferfish", "rabbit", "salmon", "sheep", "skeleton horse", "snow golem", "squid", "strider", "tropical fish", "turtle", "villager", "wandering trader"},
"mobneutral": {"bee", "cave spider", "dolphin", "enderman", "goat", "iron golem", "llama", "panda", "piglin", "polar bear", "spider", "trader llama", "wolf", "zombified piglin"},
"mobhostile": {"blaze", "chicken jockey", "creeper", "drowned", "elder guardian", "endermite", "evoker", "ghast", "guardian", "hoglin phantom", "husk", "magma cube", "phantom", "piglin brute", "pillager", "ravager", "shulker", "silverfish", "skeleton", "skeleton horseman", "slime", "spider jockey", "stray", "vex", "vindicator", "witch", "wither skeleton", "zoglin", "zombie", "zombie villager"},
"mobboss": {"ender dragon", "wither"},
"biome": {"plain", "forest", "jungle", "mountain", "desert", "taiga", "snowy tundra", "ice spike", "swamp", "savannah", "badlands", "beach", "stone shore", "river", "ocean", "mushroom island", "the nether", "the end"},
"weather": {"clear", "rain", "thunder"},
}

130
vendor/github.com/brianvoe/gofakeit/v6/data/movie.go generated vendored Normal file
View File

@ -0,0 +1,130 @@
package data
// From IMDB - Top 250 Movies subset to 100
var Movies = map[string][]string{
"name": {
"12 Years a Slave",
"1917",
"2001: A Space Odyssey",
"3 Idiots",
"A Beautiful Mind",
"A Clockwork Orange",
"Alien",
"American Beauty",
"American History X",
"Apocalypse Now",
"Avengers: Infinity War",
"Back to the Future",
"Batman Begins",
"Ben-Hur",
"Blade Runner",
"Casablanca",
"Casino",
"Catch Me If You Can",
"Das Leben der Anderen",
"Dead Poets Society",
"Die Hard",
"Django Unchained",
"Fight Club",
"Finding Nemo",
"Forrest Gump",
"Full Metal Jacket",
"Gandhi",
"Gladiator",
"Gone with the Wind",
"Good Will Hunting",
"Goodfellas",
"Green Book",
"Groundhog Day",
"Harry Potter and the Deathly Hallows - Part 2",
"Heat",
"Inception",
"Indiana Jones and the Last Crusade",
"Inglourious Basterds",
"Interstellar",
"Into the Wild",
"Intouchables",
"Joker",
"Judgment at Nuremberg",
"Jurassic Park",
"Kill Bill: Vol. 1",
"L.A. Confidential",
"La vita è bella",
"Lock, Stock and Two Smoking Barrels",
"Léon",
"Mad Max: Fury Road",
"Memento",
"Million Dollar Baby",
"Monsters, Inc.",
"Monty Python and the Holy Grail",
"No Country for Old Men",
"Once Upon a Time in America",
"One Flew Over the Cuckoo's Nest",
"Pirates of the Caribbean: The Curse of the Black Pearl",
"Platoon",
"Prisoners",
"Psycho",
"Pulp Fiction",
"Raiders of the Lost Ark",
"Ratatouille",
"Reservoir Dogs",
"Rocky",
"Saving Private Ryan",
"Scarface",
"Schindler's List",
"Se7en",
"Sherlock Jr.",
"Shutter Island",
"Snatch",
"Spider-Man: No Way Home",
"Star Wars: Episode VI - Return of the Jedi",
"Taxi Driver",
"Terminator 2: Judgment Day",
"The Big Lebowski",
"The Dark Knight",
"The Departed",
"The Empire Strikes Back",
"The Godfather",
"The Green Mile",
"The Lion King",
"The Lord of the Rings: The Fellowship of the Ring",
"The Matrix",
"The Pianist",
"The Prestige",
"The Shawshank Redemption",
"The Terminator",
"The Usual Suspects",
"The Wolf of Wall Street",
"Top Gun: Maverick",
"Toy Story",
"Unforgiven",
"Up",
"V for Vendetta",
"WALL·E",
"Warrior",
"Whiplash",
},
"genre": {
"Action",
"Adventure",
"Animation",
"Biography",
"Comedy",
"Crime",
"Drama",
"Family",
"Fantasy",
"Film-Noir",
"History",
"Horror",
"Music",
"Musical",
"Mystery",
"Romance",
"Sci-Fi",
"Sport",
"Thriller",
"War",
"Western",
},
}

211
vendor/github.com/brianvoe/gofakeit/v6/data/payment.go generated vendored Normal file
View File

@ -0,0 +1,211 @@
package data
// CreditCardInfo contains credit card info
type CreditCardInfo struct {
Display string
Patterns []uint
Gaps []uint
Lengths []uint
Code CreditCardCode
}
// CreditCardCode contains code type and size
type CreditCardCode struct {
Name string
Size uint
}
// CreditCardTypes is an array of credit card types
var CreditCardTypes = []string{"visa", "mastercard", "american-express", "diners-club", "discover", "jcb", "unionpay", "maestro", "elo", "hiper", "hipercard"}
// CreditCards contains payment information
var CreditCards = map[string]CreditCardInfo{
"visa": {
Display: "Visa",
Patterns: []uint{4},
Gaps: []uint{4, 8, 12},
Lengths: []uint{16},
Code: CreditCardCode{
Name: "CVV",
Size: 3,
},
},
"mastercard": {
Display: "Mastercard",
Patterns: []uint{
51, 55,
2221, 2229,
223, 229,
23, 26,
270, 271,
2720,
},
Gaps: []uint{4, 8, 12},
Lengths: []uint{16},
Code: CreditCardCode{
Name: "CVC",
Size: 3,
},
},
"american-express": {
Display: "American Express",
Patterns: []uint{34, 37},
Gaps: []uint{4, 10},
Lengths: []uint{15},
Code: CreditCardCode{
Name: "CID",
Size: 4,
},
},
"diners-club": {
Display: "Diners Club",
Patterns: []uint{
300, 305,
36, 38, 39,
},
Gaps: []uint{4, 10},
Lengths: []uint{14, 16, 19},
Code: CreditCardCode{
Name: "CVV",
Size: 3,
},
},
"discover": {
Display: "Discover",
Patterns: []uint{
6011, 644, 649, 65,
},
Gaps: []uint{4, 8, 12},
Lengths: []uint{16, 19},
Code: CreditCardCode{
Name: "CID",
Size: 3,
},
},
"jcb": {
Display: "JCB",
Patterns: []uint{
2131, 1800, 3528, 3589,
},
Gaps: []uint{4, 8, 12},
Lengths: []uint{16, 17, 18, 19},
Code: CreditCardCode{
Name: "CVV",
Size: 3,
},
},
"unionpay": {
Display: "UnionPay",
Patterns: []uint{
620, 624, 626,
62100, 62182,
62184, 62187,
62185, 62197,
62200, 62205,
622010, 622999,
622018,
622019, 622999,
62207, 62209,
622126, 622925,
623, 626,
6270, 6272, 6276,
627700, 627779,
627781, 627799,
6282, 6289,
6291, 6292,
810,
8110, 8131,
8132, 8151,
8152, 8163,
8164, 817,
},
Gaps: []uint{4, 8, 12},
Lengths: []uint{14, 15, 16, 17, 18, 19},
Code: CreditCardCode{
Name: "CVN",
Size: 3,
},
},
"maestro": {
Display: "Maestro",
Patterns: []uint{
493698,
500000, 506698,
506779, 508999,
56, 59,
6, 63, 67,
},
Gaps: []uint{4, 8, 12},
Lengths: []uint{12, 13, 14, 15, 16, 17, 18, 19},
Code: CreditCardCode{
Name: "CVC",
Size: 3,
},
},
"elo": {
Display: "Elo",
Patterns: []uint{
401178, 401179,
438935, 457631,
457632, 431274,
451416, 457393,
504175, 506699,
506778, 509000,
509999, 627780,
636297, 636368,
650031, 650033,
650035, 650051,
650405, 650439,
650485, 650538,
650541, 650598,
650700, 650718,
650720, 650727,
650901, 650978,
651652, 651679,
655000, 655019,
655021, 65505,
},
Gaps: []uint{4, 8, 12},
Lengths: []uint{16},
Code: CreditCardCode{
Name: "CVE",
Size: 3,
},
},
"mir": {
Display: "Mir",
Patterns: []uint{2200, 2204},
Gaps: []uint{4, 8, 12},
Lengths: []uint{16, 17, 18, 19},
Code: CreditCardCode{
Name: "CVP2",
Size: 3,
},
},
"hiper": {
Display: "Hiper",
Patterns: []uint{
637095,
637568,
637599,
637609,
637612,
},
Gaps: []uint{4, 8, 12},
Lengths: []uint{16},
Code: CreditCardCode{
Name: "CVC",
Size: 3,
},
},
"hipercard": {
Display: "Hipercard",
Patterns: []uint{606282},
Gaps: []uint{4, 8, 12},
Lengths: []uint{16},
Code: CreditCardCode{
Name: "CVC",
Size: 3,
},
},
}

12
vendor/github.com/brianvoe/gofakeit/v6/data/person.go generated vendored Normal file
View File

File diff suppressed because one or more lines are too long

64
vendor/github.com/brianvoe/gofakeit/v6/data/product.go generated vendored Normal file
View File

@ -0,0 +1,64 @@
package data
var Product = map[string][]string{
"category": {
"electronics", "clothing", "home appliances", "furniture",
"automotive parts", "beauty and personal care", "books", "sports equipment",
"toys and games", "outdoor gear", "pet supplies", "kitchenware",
"health and wellness", "tools and hardware", "office supplies",
"baby products", "jewelry", "home decor", "musical instruments",
"fitness equipment", "mobile phones", "computer accessories", "cameras and photography",
"gardening supplies", "bedding and linens", "food and groceries", "party supplies",
"craft and diy supplies", "camping gear", "watches", "luggage and travel accessories",
"board games", "art supplies", "stationery", "bath and shower products",
"sunglasses", "educational toys", "headphones and earbuds", "sneakers and athletic shoes",
"coffee and tea products", "bicycles and accessories", "cookware", "cosmetics",
"home improvement", "pet food", "laptop bags and cases", "home security systems",
"musical accessories", "skincare products", "smart home devices",
},
"adjective": {
"bold", "swift", "pure", "smart", "fresh",
"cool", "sharp", "zen", "bright", "quick",
"robust", "sleek", "versatile", "innovative", "compact",
"luxe", "modular", "precision", "stream",
},
"name": {
"phone", "laptop", "tablet", "watch", "camera",
"headphones", "speaker", "drone", "car", "bike",
"appliance", "gadget", "tool", "toy", "game",
"computer", "console", "smartwatch", "fitness tracker", "smart home device",
"robot", "router", "television", "smart speaker", "vr headset",
"earbuds", "printer", "mouse", "keyboard", "monitor",
"microwave", "blender", "vacuum", "fan", "toaster",
"clock", "lamp", "shaver", "scale", "thermometer",
"fridge", "oven", "mixer", "iron", "hair dryer",
"fan", "scale", "thermostat", "router", "lightbulb",
},
"feature": {
"wireless", "smart", "eco-friendly", "advanced", "compact",
"high-performance", "energy-efficient", "portable", "durable", "stylish",
"touchscreen", "water-resistant", "noise-canceling", "voice-controlled", "ultra-lightweight",
"multi-functional", "user-friendly", "fast-charging", "biometric", "gps-enabled",
},
"material": {
"titanium", "carbon", "alloy", "bamboo", "leather",
"glass", "ceramic", "aluminum", "stainless", "wood",
"plastic", "rubber", "silicon", "fabric", "paper",
"gold", "silver", "brass", "copper", "bronze",
"chrome", "marble", "granite", "porcelain", "plexiglass",
"quartz", "felt", "suede",
},
"suffix": {
"tech", "pro", "x", "plus", "elite",
"spark", "nexus", "nova", "fusion", "sync",
"edge", "boost", "max", "link", "prime",
"zoom", "pulse", "dash", "connect", "blaze",
"quantum", "spark", "vertex", "core", "flux",
"turbo", "shift", "wave", "matrix",
},
}

56
vendor/github.com/brianvoe/gofakeit/v6/data/school.go generated vendored Normal file
View File

@ -0,0 +1,56 @@
package data
// School type and names
var School = map[string][]string{
"type": {"Elementary School", "Middle School", "University", "High School", "Kindergarten", "Academy", "College", "Institute"},
"isPrivate": {"Private", "State"},
"name": {"Maplewood",
"Pineville",
"Riverside",
"Willowbrook",
"Crestwood",
"Sunset",
"Greenfield",
"Oakwood",
"Willowbrook",
"Hawthorn",
"Brookside",
"Pleasant View",
"Crescent Valley",
"Sycamore",
"Springfield",
"Meadowbrook",
"Greenwood",
"Riverbend",
"Valley Forge",
"Ridgeview",
"Cottonwood",
"Cedarwood",
"Golden Oak",
"Stonebridge",
"Harborview",
"Windsor",
"Northbrook",
"Sunset",
"Redwood Valley",
"Liberty",
"Washington Central",
"Franklin",
"Jefferson",
"Lincoln Park",
"Madison",
"Roosevelt",
"Westwood",
"Central Lakeside",
"Fairview",
"Heritage Hills",
"Kingsbridge",
"Harrisonville",
"Valley View",
"Hillside",
"Northridge",
"Brooklyn Heights",
"Oakridge",
"Countryside",
},
}

5
vendor/github.com/brianvoe/gofakeit/v6/data/sentence.go generated vendored Normal file
View File

File diff suppressed because one or more lines are too long

83
vendor/github.com/brianvoe/gofakeit/v6/data/word.go generated vendored Normal file
View File

@ -0,0 +1,83 @@
package data
import (
"sort"
)
var WordKeys []string
func init() {
// Loop through Word and put togther a list of keys
for key := range Word {
WordKeys = append(WordKeys, key)
}
// Sort the keys
sort.Strings(WordKeys)
}
// Word consists of common english words
var Word = map[string][]string{
// Nouns
"noun_common": {"time", "person", "year", "way", "day", "thing", "man", "world", "life", "hand", "part", "child", "eye", "woman", "place", "work", "week", "case", "point", "government", "company", "number", "group", "problem", "fact"},
"noun_concrete": {"apple", "air", "conditioner", "airport", "ambulance", "aircraft", "apartment", "arrow", "antlers", "apro", "alligator", "architect", "ankle", "armchair", "aunt", "ball", "bermudas", "beans", "balloon", "bear", "blouse", "bed", "bow", "bread", "black", "board", "bones", "bill", "bitterness", "boxers", "belt", "brain", "buffalo", "bird", "baby", "book", "back", "butter", "bulb", "buckles", "bat", "bank", "bag", "bra", "boots", "blazer", "bikini", "bookcase", "bookstore", "bus stop", "brass", "brother", "boy", "blender", "bucket", "bakery", "bow", "bridge", "boat", "car", "cow", "cap", "cooker", "cheeks", "cheese", "credenza", "carpet", "crow", "crest", "chest", "chair", "candy", "cabinet", "cat", "coffee", "children", "cookware", "chaise longue", "chicken", "casino", "cabin", "castle", "church", "cafe", "cinema", "choker", "cravat", "cane", "costume", "cardigan", "chocolate", "crib", "couch", "cello", "cashier", "composer", "cave", "country", "computer", "canoe", "clock", "dog", "deer", "donkey", "desk", "desktop", "dress", "dolphin", "doctor", "dentist", "drum", "dresser", "designer", "detective", "daughter", "egg", "elephant", "earrings", "ears", "eyes", "estate", "finger", "fox", "frock", "frog", "fan", "freezer", "fish", "film", "foot", "flag", "factory", "father", "farm", "forest", "flower", "fruit", "fork", "grapes", "goat", "gown", "garlic", "ginger", "giraffe", "gauva", "grains", "gas station", "garage", "gloves", "glasses", "gift", "galaxy", "guitar", "grandmother", "grandfather", "governor", "girl", "guest", "hamburger", "hand", "head", "hair", "heart", "house", "horse", "hen", "horn", "hat", "hammer", "hostel", "hospital", "hotel", "heels", "herbs", "host", "jacket", "jersey", "jewelry", "jaw", "jumper", "judge", "juicer", "keyboard", "kid", "kangaroo", "koala", "knife", "lemon", "lion", "leggings", "leg", "laptop", "library", "lamb", "london", "lips", "lung", "lighter", "luggage", "lamp", "lawyer", "mouse", "monkey", "mouth", "mango", "mobile", "milk", "music", "mirror", "musician", "mother", "man", "model", "mall", "museum", "market", "moonlight", "medicine", "microscope", "newspaper", "nose", "notebook", "neck", "noodles", "nurse", "necklace", "noise", "ocean", "ostrich", "oil", "orange", "onion", "oven", "owl", "paper", "panda", "pants", "palm", "pasta", "pumpkin", "pharmacist", "potato", "parfume", "panther", "pad", "pencil", "pipe", "police", "pen", "pharmacy", "police station", "parrot", "plane", "pigeon", "phone", "peacock", "pencil", "pig", "pouch", "pagoda", "pyramid", "purse", "pancake", "popcorn", "piano", "physician", "photographer", "professor", "painter", "park", "plant", "parfume", "radio", "razor", "ribs", "rainbow", "ring", "rabbit", "rice", "refrigerator", "remote", "restaurant", "road", "surgeon", "scale", "shampoo", "sink", "salt", "shark", "sandals", "shoulder", "spoon", "soap", "sand", "sheep", "sari", "stomach", "stairs", "soup", "shoes", "scissors", "sparrow", "shirt", "suitcase", "stove", "stairs", "snowman", "shower", "swan", "suit", "sweater", "smoke", "skirt", "sofa", "socks", "stadium", "skyscraper", "school", "sunglasses", "sandals", "slippers", "shorts", "sandwich", "strawberry", "spaghetti", "shrimp", "saxophone", "sister", "son", "singer", "senator", "street", "supermarket", "swimming pool", "star", "sky", "sun", "spoon", "ship", "smile", "table", "turkey", "tie", "toes", "truck", "train", "taxi", "tiger", "trousers", "tongue", "television", "teacher", "turtle", "tablet", "train station", "toothpaste", "tail", "theater", "trench coat", "tea", "tomato", "teen", "tunnel", "temple", "town", "toothbrush", "tree", "toy", "tissue", "telephone", "underwear", "uncle", "umbrella", "vest", "voice", "veterinarian", "villa", "violin", "village", "vehicle", "vase", "wallet", "wolf", "waist", "wrist", "water melon", "whale", "water", "wings", "whisker", "watch", "woman", "washing machine", "wheelchair", "waiter", "wound", "xylophone", "zebra", "zoo"},
"noun_abstract": {"fiction", "horror", "dream", "luck", "movement", "right", "clarity", "joy", "care", "trend", "belief", "sorrow", "joy", "failure", "slavery", "riches", "fashion", "envy", "success", "fear", "union", "luxury", "freedom", "generosity", "wit", "peace", "hatred", "thrill", "brilliance", "care", "wealth", "religion", "divorce", "goal", "stupidity", "friendship", "goodness", "rhythm", "timing", "infancy", "disregard", "riches", "appetite", "loneliness", "pleasure", "love", "beauty", "annoyance", "kindness", "nap", "gain", "talent", "religion", "lie", "truth", "solitude", "justice", "bravery", "calm", "childhood", "confusion", "ability", "loss", "thought", "growth", "cleverness", "anger", "horror", "marriage", "delay", "philosophy", "generation", "wisdom", "dishonesty", "happiness", "coldness", "poverty", "brilliance", "luxuty", "sleep", "awareness", "idea", "disregard", "slavery", "growth", "company", "irritation", "advantage", "mercy", "speed", "pain", "gossip", "crime", "comfort", "frailty", "life", "patience", "omen", "deceit", "elegance"},
"noun_collective_people": {"band", "troupe", "dynasty", "group", "bevy", "staff", "crowd", "party", "board", "regiment", "crew", "tribe", "body", "patrol", "congregation", "pack", "bunch", "company", "team", "mob", "caravan", "line", "troop", "choir", "host", "posse", "class", "gang", "horde"},
"noun_collective_animal": {"cackle", "mustering", "mob", "wisp", "pod", "bale", "murder", "muster", "brace", "exaltation", "party", "flock", "cast", "sedge", "stand", "scold", "team", "covey", "trip", "army", "school", "nest", "leap", "host", "troop"},
"noun_collective_thing": {"wad", "pair", "album", "string", "anthology", "reel", "outfit", "fleet", "comb", "archipelago", "quiver", "bale", "packet", "hedge", "basket", "orchard", "batch", "library", "battery", "set", "harvest", "block", "forest", "book", "group", "bouquet", "collection", "bowl", "stack", "bunch", "hand", "bundle", "catalog", "shower", "ream", "chest", "heap", "range", "cluster", "pack", "hail", "cloud", "galaxy", "sheaf", "clump"},
"noun_countable": {"camp", "hospital", "shirt", "sock", "plant", "cup", "fork", "spoon", "plate", "straw", "town", "box", "bird", "father", "answer", "egg", "purse", "mirror", "mistake", "toilet", "toothbrush", "shower", "towel", "pool", "corner", "card", "lawn", "city", "egg", "yard", "burger", "kilometer", "mile", "father", "film", "actor", "issue", "machine", "liter", "room", "station", "journey", "castle", "hour", "finger", "boy", "book", "year", "second", "son", "month", "group", "hall", "cat", "week", "picture", "day", "village", "effect", "baby", "weekend", "class", "meal", "river", "grade", "bush", "desk", "stream", "method", "brother", "sister", "factory", "aunt", "bush", "program", "uncle", "ball", "cousin", "wall", "grandmother", "cup", "grandfather", "week", "school", "shirt", "child", "king", "road", "judge", "bridge", "car", "line", "book", "eye", "teacher", "foot", "party", "face", "day", "chest", "handle", "week", "hotel", "eye", "animal", "doctor", "adult", "village", "key", "bird", "bank", "program", "idea", "gun", "card", "brother", "dress", "room", "door", "mouth", "club", "game", "ring", "project", "sister", "road", "coat", "account", "group", "cigarette", "farm", "river", "college", "computer", "walk", "corner", "cat", "head", "street", "election", "country", "chair", "crowd", "cup", "plant", "farm", "handle", "model", "book", "message", "battle", "pen", "pencil", "elephant", "carrot", "onion", "garden", "country", "engine", "bill", "apple", "noun", "club", "crowd", "window", "field", "friend", "verb", "class", "flower", "seed", "lake", "plant", "animal", "ocean", "whale", "fish", "stream", "cloud", "couch", "steak", "problem", "light", "door", "room", "painting", "shop", "apartment", "candle", "adult", "building", "plan", "page", "ball", "game", "animal", "apartment", "box", "thought", "walk", "lady", "bottle", "article", "game", "kettle", "car", "house", "hoses", "orange", "phone", "app", "window", "door", "dollar", "foot", "cent", "library", "cat", "bed", "pound", "gate", "tomatoes", "gun", "holiday", "woman", "job", "shock", "salary", "tax", "coat", "scooter", "dog", "problem", "field", "answer", "ear", "camp", "case", "road", "woman", "product", "bridge", "man", "dream", "idea", "scheme", "invention", "cigarette", "mother", "friend", "chapter", "computer", "dream", "father", "child", "motor", "deskpath", "factory", "park", "newspaper", "hat", "dream", "table", "kitchen", "student", "captain", "doctor", "bus", "neck", "class", "list", "member", "chest", "valley", "product", "horse", "captain", "star", "hour", "page", "bus", "girl", "month", "child", "house", "boy", "bill", "kitchen", "chapter", "boat", "hand", "dress", "table", "wall", "chair", "train", "minute", "magazine", "bus", "party", "bird", "lake", "job", "nation", "bike", "election", "hand", "box", "beach", "address", "project", "task", "park", "face", "college", "bell", "plane", "store", "hall", "accident", "daughter", "ship", "candy", "smile", "city", "island", "case", "spot", "film", "husband", "artist", "tour", "bag", "boat", "driver", "office", "chair", "path", "dog", "bag", "finger", "apartment", "garden", "heart", "year", "engine", "girl", "day", "castle", "plane", "ring", "brother", "edge", "picture", "meeting", "tent", "dog", "hat", "head", "bottle", "hill"},
"noun_uncountable": {"accommodation", "advertising", "air", "aid", "advice", "anger", "art", "assistance", "bread", "business", "butter", "calm", "cash", "chaos", "cheese", "childhood", "clothing", "coffee", "content", "corruption", "courage", "currency", "damage", "danger", "darkness", "data", "determination", "economics", "education", "electricity", "employment", "energy", "entertainment", "enthusiasm", "equipment", "evidence", "failure", "fame", "fire", "flour", "food", "freedom", "friendship", "fuel", "furniture", "fun", "genetics", "gold", "grammar", "guilt", "hair", "happiness", "harm", "health", "heat", "help", "homework", "honesty", "hospitality", "housework", "humour", "imagination", "importance", "information", "innocence", "intelligence", "jealousy", "juice", "justice", "kindness", "knowledge", "labour", "lack", "laughter", "leisure", "literature", "litter", "logic", "love", "luck", "magic", "management", "metal", "milk", "money", "motherhood", "motivation", "music", "nature", "news", "nutrition", "obesity", "oil", "old age", "oxygen", "paper", "patience", "permission", "pollution", "poverty", "power", "pride", "production", "progress", "pronunciation", "publicity", "punctuation", "quality", "quantity", "racism", "rain", "relaxation", "research", "respect", "rice", "room (space)", "rubbish", "safety", "salt", "sand", "seafood", "shopping", "silence", "smoke", "snow", "software", "soup", "speed", "spelling", "stress", "sugar", "sunshine", "tea", "tennis", "time", "tolerance", "trade", "traffic", "transportation", "travel", "trust", "understanding", "unemployment", "usage", "violence", "vision", "warmth", "water", "wealth", "weather", "weight", "welfare", "wheat", "width", "wildlife", "wisdom", "wood", "work", "yoga", "youth"},
"noun_determiner": {"the", "a", "an", "this", "that", "these", "those", "my", "your", "his", "her", "its", "our", "their", "some", "any", "each", "every", "certain"},
//"noun_proper": {}, // This refers to an actual person(John Doe), place(Chipotle, Tennessee)
// Verbs
"verb_action": {"ride", "sit", "stand", "fight", "laugh", "read", "play", "listen", "cry", "think", "sing", "watch", "dance", "turn", "win", "fly", "cut", "throw", "sleep", "close", "open", "write", "give", "jump", "eat", "drink", "cook", "wash", "wait", "climb", "talk", "crawl", "dream", "dig", "clap", "knit", "sew", "smell", "kiss", "hug", "snore", "bathe", "bow", "paint", "dive", "ski", "stack", "buy", "shake"},
"verb_transitive": {"accept", "acknowledge", "admit", "aggravate", "answer", "ask", "avoid", "beat", "bend", "bless", "bother", "break", "brush", "build", "cancel", "capture", "carry", "catch", "change", "chase", "chastise", "clean", "collect", "comfort", "contradict", "convert", "crack", "dazzle", "deceive", "define", "describe", "destroy", "discover", "distinguish", "drag", "dress", "dunk", "edify", "embarrass", "embrace", "enable", "encourage", "enlist", "entertain", "execute", "fascinate", "finish", "flick", "follow", "forget", "forgive", "freeze", "frighten", "furnish", "gather", "grab", "grasp", "grease", "grip", "handle", "hang", "head", "help", "highlight", "honour", "hurry", "hurt", "imitate", "impress", "indulge", "insert", "inspect", "interest", "interrupt", "intimidate", "involve", "irritate", "join", "judge", "keep", "key", "kill", "kiss", "knock", "lag", "lay", "lead", "lean", "leave", "lighten", "limit", "link", "load", "love", "lower", "maintain", "marry", "massage", "melt", "mock", "munch", "murder", "notice", "number", "offend", "order", "page", "paralyze", "persuade", "petrify", "pierce", "place", "please", "poison", "possess", "prepare", "promise", "protect", "punch", "purchase", "puzzle", "question", "quit", "raise", "reassure", "recognise", "refill", "remind", "remove", "repel", "research", "retard", "ring", "run", "satisfy", "scold", "select", "slap", "smell", "soften", "specify", "spell", "spit", "spread", "strike", "surprise", "swallow", "switch", "taste", "teach", "tickle", "tighten", "toast", "toss", "transform", "try", "turn", "tweak", "twist", "understand", "understimate", "unload", "unlock", "untie", "upgrade", "use", "vacate", "videotape", "vilify", "viplate", "wake", "want", "warm", "warn", "wash", "watch", "wear", "weep", "widen", "win", "wipe", "wrack", "wrap", "wreck"},
"verb_intransitive": {"agree", "appear", "arrive", "become", "belong", "collapse", "consist", "cost", "cough", "cry", "depend", "die", "disappear", "emerge", "exist", "explode", "fade", "fall", "fast", "float", "fly", "gallop", "go", "grow", "happen", "have", "hiccup", "inquire", "jump", "kneel", "knock", "last", "laugh", "lead", "lean", "leap", "learn", "left", "lie", "limp", "listen", "live", "look", "march", "mourn", "move", "occur", "panic", "party", "pause", "peep", "pose", "pounce", "pout", "pray", "preen", "read", "recline", "relax", "relent", "remain", "respond", "result", "revolt", "rise", "roll", "run", "rush", "sail", "scream", "shake", "shout", "sigh", "sit", "skip", "sleep", "slide", "smell", "smile", "snarl", "sneeze", "soak", "spin", "spit", "sprint", "squeak", "stagger", "stand", "stay", "swim", "swing", "twist", "vanish", "vomit", "wade", "wait", "wake", "walk", "wander", "wave", "whirl", "wiggle", "work", "yell"},
"verb_linking": {"am", "is", "was", "are", "were", "being", "been", "be", "have", "has", "had", "do", "does", "did", "shall", "will", "should", "would", "may", "might", "must", "can", "could"},
"verb_helping": {"is", "can", "be", "do", "may", "had", "should", "was", "has", "could", "are", "will", "been", "did", "might", "were", "does", "must", "have", "would", "am", "shall", "being"},
// Adverbs
"adverb_manner": {"accidentally", "angrily", "anxiously", "awkwardly", "badly", "beautifully", "blindly", "boldly", "bravely", "brightly", "busily", "calmly", "carefully", "carelessly", "cautiously", "cheerfully", "clearly", "closely", "correctly", "courageously", "cruelly", "daringly", "deliberately", "doubtfully", "eagerly", "easily", "elegantly", "enormously", "enthusiastically", "equally", "eventually", "exactly", "faithfully", "fast", "fatally", "fiercely", "fondly", "foolishly", "fortunately", "frankly", "frantically", "generously", "gently", "gladly", "gracefully", "greedily", "happily", "hard", "hastily", "healthily", "honestly", "hungrily", "hurriedly", "inadequately", "ingeniously", "innocently", "inquisitively", "irritably", "joyously", "justly", "kindly", "lazily", "loosely", "loudly", "madly", "mortally", "mysteriously", "neatly", "nervously", "noisily", "obediently", "openly", "painfully", "patiently", "perfectly", "politely", "poorly", "powerfully", "promptly", "punctually", "quickly", "quietly", "rapidly", "rarely", "really", "recklessly", "regularly", "reluctantly", "repeatedly", "rightfully", "roughly", "rudely", "sadly", "safely", "selfishly", "sensibly", "seriously", "sharply", "shyly", "silently", "sleepily", "slowly", "smoothly", "so", "softly", "solemnly", "speedily", "stealthily", "sternly", "straight", "stupidly", "successfully", "suddenly", "suspiciously", "swiftly", "tenderly", "tensely", "thoughtfully", "tightly", "truthfully", "unexpectedly", "victoriously", "violently", "vivaciously", "warmly", "weakly", "wearily", "well", "wildly", "wisely"},
"adverb_degree": {"almost", "absolutely", "awfully", "badly", "barely", "completely", "decidedly", "deeply", "enough", "enormously", "entirely", "extremely", "fairly", "far", "fully", "greatly", "hardly", "highly", "how", "incredibly", "indeed", "intensely", "just", "least", "less", "little", "lots", "most", "much", "nearly", "perfectly", "positively", "practically", "pretty", "purely", "quite", "rather", "really", "scarcely", "simply", "so", "somewhat", "strongly", "terribly", "thoroughly", "too", "totally", "utterly", "very", "virtually", "well"},
"adverb_place": {"about", "above", "abroad", "anywhere", "away", "back", "backwards", "behind", "below", "down", "downstairs", "east", "elsewhere", "far", "here", "in", "indoors", "inside", "near", "nearby", "off", "on", "out", "outside", "over", "there", "towards", "under", "up", "upstairs", "where"},
"adverb_time_definite": {"now", "then", "today", "tomorrow", "tonight", "yesterday"},
"adverb_time_indefinite": {"already", "before", "early", "earlier", "eventually", "finally", "first", "formerly", "just", "last", "late", "later", "lately", "next", "previously", "recently", "since", "soon", "still", "yet"},
"adverb_frequency_definite": {"annually", "daily", "fortnightly", "hourly", "monthly", "nightly", "quarterly", "weekly", "yearly"},
"adverb_frequency_indefinite": {"always", "constantly", "ever", "frequently", "generally", "infrequently", "never", "normally", "occasionally", "often", "rarely", "regularly", "seldom", "sometimes", "regularly", "usually"},
// Prepositions
"preposition_simple": {"at", "by", "as", "but", "from", "for", "into", "in", "than", "of", "off", "on", "out", "over", "till", "to", "up", "upon", "with", "under", "down"},
"preposition_double": {"outside of", "out of", "upon", "within", "inside", "without", "onto", "from behind", "because of", "out of", "throughout", "up to", "before", "due to", "according to", "from beneath", "next to", "from above"},
"preposition_compound": {"according to", "as to", "onto", "across", "after", "beyond", "without", "opposite to", "away from", "aside from", "in favor of", "in front of", "because of", "as for", "near to", "behind", "along", "outside", "on account of", "on behalf of", "but for", "ahead of", "close to", "despite", "depending on", "due to", "in addition to", "next to", "in between", "in case of", "owing to", "along with", "around", "between", "apart from", "in return for", "out of", "instead of", "outside of", "other than", "together with", "up to", "above", "about"},
// Adjectives
"adjective_descriptive": {"adorable", "adventurous", "agreeable", "alive", "aloof", "amused", "angry", "annoying", "anxious", "arrogant", "ashamed", "attractive", "auspicious", "awful", "bad", "beautiful", "black", "blue", "blushing", "bored", "brave", "bright", "brown", "busy", "calm", "careful", "cautious", "charming", "cheerful", "clean", "clear", "clever", "clumsy", "colorful", "comfortable", "concerning", "condemned", "confusing", "cooperative", "courageous", "creepy", "crowded", "cruel", "curios", "cute", "dangerous", "dark", "defiant", "delightful", "difficult", "disgusting", "distinct", "disturbed", "dizzying", "drab", "dull", "eager", "easy", "elated", "elegant", "embarrassed", "enchanted", "encouraging", "energetic", "enthusiastic", "envious", "evil", "exciting", "expensive", "exuberant", "faithful", "famous", "fancy", "fantastic", "fierce", "filthy", "fine", "foolish", "fragile", "frail", "frantic", "friendly", "frightening", "funny", "gentle", "gifted", "glamorous", "gleaming", "glorious", "good", "gorgeous", "graceful", "green", "grieving", "grumpy", "handsome", "happy", "healthy", "helpful", "helpless", "hilarious", "homeless", "horrible", "hungry", "hurt", "ill", "important", "impossible", "impromptu", "improvised", "inexpensive", "innocent", "inquiring", "itchy", "jealous", "jittery", "joyous", "kind", "knightly", "lazy", "lemony", "light", "lingering", "lively", "lonely", "long", "lovely", "lucky", "magnificent", "modern", "motionless", "muddy", "mushy", "mysterious", "naughty", "niche", "nervous", "nice", "nutty", "obedient", "obnoxious", "odd", "open", "orange", "outrageous", "outstanding", "panicked", "perfect", "pink", "plain", "pleasant", "poised", "poor", "powerless", "precious", "prickling", "proud", "purple", "puzzled", "quaint", "queer", "quizzical", "realistic", "red", "relieved", "repelling", "repulsive", "rich", "scary", "scenic", "selfish", "shiny", "shy", "silly", "sleepy", "smiling", "smoggy", "sore", "sparkly", "splendid", "spotted", "stormy", "strange", "stupid", "successful", "super", "talented", "tame", "tasty", "tender", "tense", "terse", "terrible", "thankful", "thoughtful", "tired", "tough", "troubling", "ugly", "uninterested", "unusual", "upset", "uptight", "varied", "vast", "victorious", "wandering", "weary", "white", "wicked", "wide", "wild", "witty", "worrisome", "wrong", "yellow", "young", "zealous"},
"adjective_quantitative": {"a little", "a little bit", "a lot", "abundant", "all", "any", "couple", "double", "each", "either", "empty", "enough", "enough of", "every", "few", "full", "great", "half", "heavily", "heavy", "huge", "hundred", "hundreds", "insufficient", "light", "little", "lots of", "many", "most", "much", "neither", "no", "numerous", "plenty of", "several", "significant", "single", "so few", "some", "sparse", "substantial", "sufficient", "too", "whole"},
"adjective_proper": {"Afghan", "African", "Alaskan", "Alpine", "Amazonian", "American", "Antarctic", "Aristotelian", "Asian", "Atlantean", "Atlantic", "Bahamian", "Bahrainean", "Balinese", "Bangladeshi", "Barbadian", "Barcelonian", "Beethovenian", "Belgian", "Beninese", "Bismarckian", "Brazilian", "British", "Buddhist", "Burkinese", "Burmese", "Caesarian", "Californian", "Cambodian", "Canadian", "Chinese", "Christian", "Colombian", "Confucian", "Congolese", "Cormoran", "Costa Rican", "Cypriot", "Danish", "Darwinian", "Diabolical", "Dutch", "Ecuadorian", "Egyptian", "Einsteinian", "Elizabethan", "English", "Finnish", "French", "Freudian", "Gabonese", "Gaussian", "German", "Greek", "Guyanese", "Himalayan", "Hindu", "Hitlerian", "Honduran", "Icelandic", "Indian", "Indonesian", "Intelligent", "Iranian", "Iraqi", "Italian", "Japanese", "Jungian", "Kazakh", "Korean", "kuban", "Kyrgyz", "Laotian", "Lebanese", "Lilliputian", "Lincolnian", "Machiavellian", "Madagascan", "Malagasy", "Marxist", "Mayan", "Mexican", "Middle Eastern", "Monacan", "Mozartian", "Muscovite", "Nepalese", "Newtonian", "Norwegian", "Orwellian", "Pacific", "Parisian", "Peruvian", "Philippine", "Plutonian", "Polish", "Polynesian", "Portuguese", "Putinist", "Roman", "Romanian", "Rooseveltian", "Russian", "Salvadorean", "Sammarinese", "Senegalese", "Shakespearean", "Slovak", "Somali", "South American", "Spanish", "Spanish", "Sri-Lankan", "Sudanese", "Swazi", "Swiss", "Taiwanese", "Thai", "Thatcherite", "Tibetan", "Torontonian", "Turkish", "Turkishish", "Turkmen", "Uzbek", "Victorian", "Viennese", "Vietnamese", "Welsh"},
"adjective_demonstrative": {"this", "that", "these", "those", "it", "here", "there", "over there"},
"adjective_possessive": {"my", "your", "his", "her", "its", "our", "their"},
"adjective_interrogative": {"what", "whose", "where", "why", "how", "which"},
"adjective_indefinite": {"all", "any", "anything", "everyone", "few", "nobody", "one", "some", "someone", "everybody", "anyone", "each", "everything", "many", "none", "several", "somebody"},
// Pronouns
"pronoun_personal": {"I", "we", "you", "he", "she", "it", "they"},
"pronoun_object": {"me", "us", "you", "her", "him", "it", "them"},
"pronoun_possessive": {"mine", "ours", "yours", "hers", "his", "theirs"},
"pronoun_reflective": {"myself", "yourself", "herself", "himself", "itself", "ourselves", "yourselves", "themselves"},
"pronoun_indefinite": {"all", "another", "any", "anybody", "anyone", "anything", "both", "each", "either", "everybody", "everyone", "everything", "few", "many", "most", "neither", "nobody", "none", "no one", "nothing", "one", "other", "others", "several", "some", "somebody", "someone", "something", "such"},
"pronoun_demonstrative": {"this", "that", "these", "those"},
"pronoun_interrogative": {"who", "whom", "which", "what", "whose", "where", "when", "why", "how"},
"pronoun_relative": {"as", "that", "what", "whatever", "which", "whichever", "who", "whoever", "whom", "whomever", "whose"},
// Connectives
"connective_time": {"after a while", "afterwards", "at once", "at this moment", "at this point", "before that", "finally", "first", "here", "in the end", "lastly", "later on", "meanwhile", "next", "next time", "now", "on another occasion", "previously", "since", "soon", "straightaway", "then", "until then", "when", "whenever", "while"},
"connective_comparative": {"additionally", "also", "as well", "even", "furthermore", "in addition", "indeed", "let alone", "moreover", "not only", "alternatively", "anyway", "but", "by contrast", "differs from", "elsewhere", "even so", "however", "in contrast", "in fact", "in other respects", "in spite of this", "in that respect", "instead", "nevertheless", "on the contrary", "on the other hand", "rather", "though", "whereas", "yet", "after all", "anyway", "besides", "moreover"},
"connective_complaint": {"besides", "e.g.", "for example", "for instance", "i.e.", "in other words", "in that", "that is to say"},
"connective_listing": {"firstly", "secondly", "first of all", "finally", "lastly", "for one thing", "for another", "in the first place", "to begin with", "next", "in summation", "to conclude"},
"connective_casual": {"accordingly", "all the same", "an effect of", "an outcome of", "an upshot of", "as a consequence of", "as a result of", "because", "caused by", "consequently", "despite this", "even though", "hence", "however", "in that case", "moreover", "nevertheless", "otherwise", "so", "so as", "stemmed from", "still", "then", "therefore", "though", "under the circumstances", "yet"},
"connective_examplify": {"accordingly", "as a result", "as exemplified by", "consequently", "for example", "for instance", "for one thing", "including", "provided that", "since", "so", "such as", "then", "therefore", "these include", "through", "unless", "without"},
// Misc
"interjection": {"wow", "hey", "oops", "ouch", "yay", "aha", "eek", "huh", "hmm", "whoa", "yikes", "phew", "gee", "alas", "bravo"},
}

4
vendor/github.com/brianvoe/gofakeit/v6/doc.go generated vendored Normal file
View File

@ -0,0 +1,4 @@
/*
Package gofakeit provides a set of functions that generate random data
*/
package gofakeit

100
vendor/github.com/brianvoe/gofakeit/v6/emoji.go generated vendored Normal file
View File

@ -0,0 +1,100 @@
package gofakeit
import "math/rand"
// Emoji will return a random fun emoji
func Emoji() string { return emoji(globalFaker.Rand) }
// Emoji will return a random fun emoji
func (f *Faker) Emoji() string { return emoji(f.Rand) }
func emoji(r *rand.Rand) string { return getRandValue(r, []string{"emoji", "emoji"}) }
// EmojiDescription will return a random fun emoji description
func EmojiDescription() string { return emojiDescription(globalFaker.Rand) }
// EmojiDescription will return a random fun emoji description
func (f *Faker) EmojiDescription() string { return emojiDescription(f.Rand) }
func emojiDescription(r *rand.Rand) string { return getRandValue(r, []string{"emoji", "description"}) }
// EmojiCategory will return a random fun emoji category
func EmojiCategory() string { return emojiCategory(globalFaker.Rand) }
// EmojiCategory will return a random fun emoji category
func (f *Faker) EmojiCategory() string { return emojiCategory(f.Rand) }
func emojiCategory(r *rand.Rand) string { return getRandValue(r, []string{"emoji", "category"}) }
// EmojiAlias will return a random fun emoji alias
func EmojiAlias() string { return emojiAlias(globalFaker.Rand) }
// EmojiAlias will return a random fun emoji alias
func (f *Faker) EmojiAlias() string { return emojiAlias(f.Rand) }
func emojiAlias(r *rand.Rand) string { return getRandValue(r, []string{"emoji", "alias"}) }
// EmojiTag will return a random fun emoji tag
func EmojiTag() string { return emojiTag(globalFaker.Rand) }
// EmojiTag will return a random fun emoji tag
func (f *Faker) EmojiTag() string { return emojiTag(f.Rand) }
func emojiTag(r *rand.Rand) string { return getRandValue(r, []string{"emoji", "tag"}) }
func addEmojiLookup() {
AddFuncLookup("emoji", Info{
Display: "Emoji",
Category: "emoji",
Description: "Digital symbol expressing feelings or ideas in text messages and online chats",
Example: "🤣",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return emoji(r), nil
},
})
AddFuncLookup("emojidescription", Info{
Display: "Emoji Description",
Category: "emoji",
Description: "Brief explanation of the meaning or emotion conveyed by an emoji",
Example: "face vomiting",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return emojiDescription(r), nil
},
})
AddFuncLookup("emojicategory", Info{
Display: "Emoji Category",
Category: "emoji",
Description: "Group or classification of emojis based on their common theme or use, like 'smileys' or 'animals'",
Example: "Smileys & Emotion",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return emojiCategory(r), nil
},
})
AddFuncLookup("emojialias", Info{
Display: "Emoji Alias",
Category: "emoji",
Description: "Alternative name or keyword used to represent a specific emoji in text or code",
Example: "smile",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return emojiAlias(r), nil
},
})
AddFuncLookup("emojitag", Info{
Display: "Emoji Tag",
Category: "emoji",
Description: "Label or keyword associated with an emoji to categorize or search for it easily",
Example: "happy",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return emojiTag(r), nil
},
})
}

233
vendor/github.com/brianvoe/gofakeit/v6/error.go generated vendored Normal file
View File

@ -0,0 +1,233 @@
package gofakeit
import (
"errors"
"math/rand"
)
// Error will return a random generic error
func Error() error {
return err(globalFaker.Rand)
}
// Error will return a random generic error
func (f *Faker) Error() error {
return err(f.Rand)
}
func err(r *rand.Rand) error {
return errors.New(generate(r, getRandValue(r, []string{"error", "generic"})))
}
// ErrorObject will return a random error object word
func ErrorObject() error {
return errorObject(globalFaker.Rand)
}
// ErrorObject will return a random error object word
func (f *Faker) ErrorObject() error {
return errorObject(f.Rand)
}
func errorObject(r *rand.Rand) error {
return errors.New(generate(r, getRandValue(r, []string{"error", "object"})))
}
// ErrorDatabase will return a random database error
func ErrorDatabase() error {
return errorDatabase(globalFaker.Rand)
}
// ErrorDatabase will return a random database error
func (f *Faker) ErrorDatabase() error {
return errorDatabase(f.Rand)
}
func errorDatabase(r *rand.Rand) error {
return errors.New(generate(r, getRandValue(r, []string{"error", "database"})))
}
// ErrorGRPC will return a random gRPC error
func ErrorGRPC() error {
return errorGRPC(globalFaker.Rand)
}
// ErrorGRPC will return a random gRPC error
func (f *Faker) ErrorGRPC() error {
return errorGRPC(f.Rand)
}
func errorGRPC(r *rand.Rand) error {
return errors.New(generate(r, getRandValue(r, []string{"error", "grpc"})))
}
// ErrorHTTP will return a random HTTP error
func ErrorHTTP() error {
return errorHTTP(globalFaker.Rand)
}
// ErrorHTTP will return a random HTTP error
func (f *Faker) ErrorHTTP() error {
return errorHTTP(f.Rand)
}
func errorHTTP(r *rand.Rand) error {
return errors.New(generate(r, getRandValue(r, []string{"error", "http"})))
}
// ErrorHTTPClient will return a random HTTP client error response (400-418)
func ErrorHTTPClient() error {
return errorHTTPClient(globalFaker.Rand)
}
// ErrorHTTPClient will return a random HTTP client error response (400-418)
func (f *Faker) ErrorHTTPClient() error {
return errorHTTPClient(f.Rand)
}
func errorHTTPClient(r *rand.Rand) error {
return errors.New(generate(r, getRandValue(r, []string{"error", "http_client"})))
}
// ErrorHTTPServer will return a random HTTP server error response (500-511)
func ErrorHTTPServer() error {
return errorHTTPServer(globalFaker.Rand)
}
// ErrorHTTPServer will return a random HTTP server error response (500-511)
func (f *Faker) ErrorHTTPServer() error {
return errorHTTPServer(f.Rand)
}
func errorHTTPServer(r *rand.Rand) error {
return errors.New(generate(r, getRandValue(r, []string{"error", "http_server"})))
}
// ErrorRuntime will return a random runtime error
func ErrorRuntime() error {
return errorRuntime(globalFaker.Rand)
}
// ErrorRuntime will return a random runtime error
func (f *Faker) ErrorRuntime() error {
return errorRuntime(f.Rand)
}
func errorRuntime(r *rand.Rand) error {
return errors.New(generate(r, getRandValue(r, []string{"error", "runtime"})))
}
// ErrorValidation will return a random validation error
func ErrorValidation() error {
return errorValidation(globalFaker.Rand)
}
// ErrorValidation will return a random validation error
func (f *Faker) ErrorValidation() error {
return errorValidation(f.Rand)
}
func errorValidation(r *rand.Rand) error {
return errors.New(generate(r, getRandValue(r, []string{"error", "validation"})))
}
func addErrorLookup() {
AddFuncLookup("error", Info{
Display: "Error",
Category: "error",
Description: "Message displayed by a computer or software when a problem or mistake is encountered",
Example: "syntax error",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return err(r), nil
},
})
AddFuncLookup("errorobject", Info{
Display: "Error object word",
Category: "error",
Description: "Various categories conveying details about encountered errors",
Example: "protocol",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return errorObject(r), nil
},
})
AddFuncLookup("errordatabase", Info{
Display: "Database error",
Category: "error",
Description: "A problem or issue encountered while accessing or managing a database",
Example: "sql error",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return errorDatabase(r), nil
},
})
AddFuncLookup("errorgrpc", Info{
Display: "gRPC error",
Category: "error",
Description: "Communication failure in the high-performance, open-source universal RPC framework",
Example: "client protocol error",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return errorGRPC(r), nil
},
})
AddFuncLookup("errorhttp", Info{
Display: "HTTP error",
Category: "error",
Description: "A problem with a web http request",
Example: "invalid method",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return errorHTTP(r), nil
},
})
AddFuncLookup("errorhttpclient", Info{
Display: "HTTP client error",
Category: "error",
Description: "Failure or issue occurring within a client software that sends requests to web servers",
Example: "request timeout",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return errorHTTPClient(r), nil
},
})
AddFuncLookup("errorhttpserver", Info{
Display: "HTTP server error",
Category: "error",
Description: "Failure or issue occurring within a server software that recieves requests from clients",
Example: "internal server error",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return errorHTTPServer(r), nil
},
})
AddFuncLookup("errorruntime", Info{
Display: "Runtime error",
Category: "error",
Description: "Malfunction occuring during program execution, often causing abrupt termination or unexpected behavior",
Example: "address out of bounds",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return errorRuntime(r), nil
},
})
AddFuncLookup("errorvalidation", Info{
Display: "Validation error",
Category: "error",
Description: "Occurs when input data fails to meet required criteria or format specifications",
Example: "missing required field",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return errorValidation(r), nil
},
})
}

83
vendor/github.com/brianvoe/gofakeit/v6/fakeable.go generated vendored Normal file
View File

@ -0,0 +1,83 @@
package gofakeit
import (
"errors"
"fmt"
"reflect"
)
// Fakeable is an interface that can be implemented by a type to provide a custom fake value.
type Fakeable interface {
// Fake returns a fake value for the type.
Fake(faker *Faker) (any, error)
}
func isFakeable(t reflect.Type) bool {
fakeableTyp := reflect.TypeOf((*Fakeable)(nil)).Elem()
return t.Implements(fakeableTyp) || reflect.PtrTo(t).Implements(fakeableTyp)
}
func callFake(faker *Faker, v reflect.Value, possibleKinds ...reflect.Kind) (any, error) {
f, ok := v.Addr().Interface().(Fakeable)
if !ok {
return nil, errors.New("not a Fakeable type")
}
fakedValue, err := f.Fake(faker)
if err != nil {
return nil, fmt.Errorf("error calling Fake: %w", err)
}
k := reflect.TypeOf(fakedValue).Kind()
if !containsKind(possibleKinds, k) {
return nil, fmt.Errorf("returned value kind %q is not amongst the valid ones: %v", k, possibleKinds)
}
switch k {
case reflect.String:
return reflect.ValueOf(fakedValue).String(), nil
case reflect.Bool:
return reflect.ValueOf(fakedValue).Bool(), nil
case reflect.Int:
return int(reflect.ValueOf(fakedValue).Int()), nil
case reflect.Int8:
return int8(reflect.ValueOf(fakedValue).Int()), nil
case reflect.Int16:
return int16(reflect.ValueOf(fakedValue).Int()), nil
case reflect.Int32:
return int32(reflect.ValueOf(fakedValue).Int()), nil
case reflect.Int64:
return int64(reflect.ValueOf(fakedValue).Int()), nil
case reflect.Uint:
return uint(reflect.ValueOf(fakedValue).Uint()), nil
case reflect.Uint8:
return uint8(reflect.ValueOf(fakedValue).Uint()), nil
case reflect.Uint16:
return uint16(reflect.ValueOf(fakedValue).Uint()), nil
case reflect.Uint32:
return uint32(reflect.ValueOf(fakedValue).Uint()), nil
case reflect.Uint64:
return uint64(reflect.ValueOf(fakedValue).Uint()), nil
case reflect.Float32:
return float32(reflect.ValueOf(fakedValue).Float()), nil
case reflect.Float64:
return float64(reflect.ValueOf(fakedValue).Float()), nil
case reflect.Slice:
return reflect.ValueOf(fakedValue).Interface(), nil
case reflect.Map:
return reflect.ValueOf(fakedValue).Interface(), nil
case reflect.Struct:
return reflect.ValueOf(fakedValue).Interface(), nil
default:
return nil, fmt.Errorf("unsupported type %q", k)
}
}
func containsKind(possibleKinds []reflect.Kind, kind reflect.Kind) bool {
for _, k := range possibleKinds {
if k == kind {
return true
}
}
return false
}

103
vendor/github.com/brianvoe/gofakeit/v6/faker.go generated vendored Normal file
View File

@ -0,0 +1,103 @@
package gofakeit
import (
crand "crypto/rand"
"encoding/binary"
"math/rand"
"sync"
)
// Create global variable to deal with global function call.
var globalFaker *Faker = New(0)
// Faker struct is the primary struct for using localized.
type Faker struct {
Rand *rand.Rand
}
type lockedSource struct {
lk sync.Mutex
src rand.Source64
}
func (r *lockedSource) Int63() (n int64) {
r.lk.Lock()
n = r.src.Int63()
r.lk.Unlock()
return
}
func (r *lockedSource) Uint64() (n uint64) {
r.lk.Lock()
n = r.src.Uint64()
r.lk.Unlock()
return
}
func (r *lockedSource) Seed(seed int64) {
r.lk.Lock()
r.src.Seed(seed)
r.lk.Unlock()
}
type cryptoRand struct {
sync.Mutex
buf []byte
}
func (c *cryptoRand) Seed(seed int64) {}
func (c *cryptoRand) Uint64() uint64 {
// Lock to make reading thread safe
c.Lock()
defer c.Unlock()
crand.Read(c.buf)
return binary.BigEndian.Uint64(c.buf)
}
func (c *cryptoRand) Int63() int64 {
return int64(c.Uint64() & ^uint64(1<<63))
}
// New will utilize math/rand for concurrent random usage.
// Setting seed to 0 will use crypto/rand for the initial seed number.
func New(seed int64) *Faker {
// If passing 0 create crypto safe int64 for initial seed number
if seed == 0 {
binary.Read(crand.Reader, binary.BigEndian, &seed)
}
return &Faker{Rand: rand.New(&lockedSource{src: rand.NewSource(seed).(rand.Source64)})}
}
// NewUnlocked will utilize math/rand for non concurrent safe random usage.
// Setting seed to 0 will use crypto/rand for the initial seed number.
// NewUnlocked is more performant but not safe to run concurrently.
func NewUnlocked(seed int64) *Faker {
// If passing 0 create crypto safe int64 for initial seed number
if seed == 0 {
binary.Read(crand.Reader, binary.BigEndian, &seed)
}
return &Faker{Rand: rand.New(rand.NewSource(seed))}
}
// NewCrypto will utilize crypto/rand for concurrent random usage.
func NewCrypto() *Faker {
return &Faker{Rand: rand.New(&cryptoRand{
buf: make([]byte, 8),
})}
}
// NewCustom will utilize a custom rand.Source64 for concurrent random usage
// See https://golang.org/src/math/rand/rand.go for required interface methods
func NewCustom(source rand.Source64) *Faker {
return &Faker{Rand: rand.New(source)}
}
// SetGlobalFaker will allow you to set what type of faker is globally used. Defailt is math/rand
func SetGlobalFaker(faker *Faker) {
globalFaker = faker
}

43
vendor/github.com/brianvoe/gofakeit/v6/file.go generated vendored Normal file
View File

@ -0,0 +1,43 @@
package gofakeit
import "math/rand"
// FileExtension will generate a random file extension
func FileExtension() string { return fileExtension(globalFaker.Rand) }
// FileExtension will generate a random file extension
func (f *Faker) FileExtension() string { return fileExtension(f.Rand) }
func fileExtension(r *rand.Rand) string { return getRandValue(r, []string{"file", "extension"}) }
// FileMimeType will generate a random mime file type
func FileMimeType() string { return fileMimeType(globalFaker.Rand) }
// FileMimeType will generate a random mime file type
func (f *Faker) FileMimeType() string { return fileMimeType(f.Rand) }
func fileMimeType(r *rand.Rand) string { return getRandValue(r, []string{"file", "mime_type"}) }
func addFileLookup() {
AddFuncLookup("fileextension", Info{
Display: "File Extension",
Category: "file",
Description: "Suffix appended to a filename indicating its format or type",
Example: "nes",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return fileExtension(r), nil
},
})
AddFuncLookup("filemimetype", Info{
Display: "File Mime Type",
Category: "file",
Description: "Defines file format and nature for browsers and email clients using standardized identifiers",
Example: "application/json",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return fileMimeType(r), nil
},
})
}

128
vendor/github.com/brianvoe/gofakeit/v6/finance.go generated vendored Normal file
View File

@ -0,0 +1,128 @@
package gofakeit
import (
"math/rand"
"strconv"
"unicode"
)
const cusipStr = upperStr + numericStr
// CUSIP
func Cusip() string {
return cusip(globalFaker.Rand)
}
func (f *Faker) Cusip() string {
return cusip(f.Rand)
}
func cusip(r *rand.Rand) string {
cusipBytes := make([]byte, 8)
for i := 0; i < len(cusipBytes); i++ {
cusipBytes[i] = byte(cusipStr[r.Intn(len(cusipStr))])
}
baseCusip := string(cusipBytes)
chkDigit := cusipChecksumDigit(baseCusip)
return baseCusip + chkDigit
}
// ISIN
func Isin() string {
return isin(globalFaker.Rand)
}
func (f *Faker) Isin() string {
return isin(f.Rand)
}
func isin(r *rand.Rand) string {
countryCode := CountryAbr()
nsin := cusip(r)
isinChkDig := isinChecksumDigit(countryCode + nsin)
return countryCode + nsin + isinChkDig
}
// cusipChecksumDigit returns the checksum digit for a CUSIP
func cusipChecksumDigit(cusip string) string {
sum := 0
for i, c := range cusip {
v := 0
if unicode.IsDigit(c) {
v = int(c - '0')
}
if unicode.IsLetter(c) {
//0-indexed ordinal position of Letter + 10
v = int(c-'A') + 10
}
if i%2 != 0 {
// Multiply odd digits by two
v = v * 2
}
sum = sum + int(v/10) + v%10
}
return strconv.Itoa((10 - (sum % 10)) % 10)
}
// isinChecksumDigit returns the checksum digit for an ISIN
func isinChecksumDigit(isin string) string {
isinDigits := make([]int, 0)
for _, c := range isin {
if unicode.IsLetter(c) {
letterVal := int(c) - 55
// Each digit is added as a separate value
isinDigits = append(isinDigits, letterVal/10)
isinDigits = append(isinDigits, letterVal%10)
}
if unicode.IsDigit(c) {
isinDigits = append(isinDigits, int(c-'0'))
}
}
oddSum := 0
evenSum := 0
// Take the per digit sum of the digitized ISIN, doubling even indexed digits
for i, d := range isinDigits {
if i%2 == 0 {
elem := 2 * d
if elem > 9 {
// If the element now has two digits, sum those digits
elem = (elem % 10) + (elem / 10)
}
evenSum += elem
} else {
oddSum += d
}
}
return strconv.Itoa((10 - (oddSum+evenSum)%10) % 10)
}
// Lookup Adds
func addFinanceLookup() {
AddFuncLookup("cusip", Info{
Display: "CUSIP",
Category: "finance",
Description: "Unique identifier for securities, especially bonds, in the United States and Canada",
Example: "38259P508",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return cusip(r), nil
},
})
AddFuncLookup("isin", Info{
Display: "ISIN",
Category: "finance",
Description: "International standard code for uniquely identifying securities worldwide",
Example: "CVLRQCZBXQ97",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return isin(r), nil
},
})
}

178
vendor/github.com/brianvoe/gofakeit/v6/food.go generated vendored Normal file
View File

@ -0,0 +1,178 @@
package gofakeit
import (
"math/rand"
"strings"
)
// Fruit will return a random fruit name
func Fruit() string { return fruit(globalFaker.Rand) }
// Fruit will return a random fruit name
func (f *Faker) Fruit() string { return fruit(f.Rand) }
func fruit(r *rand.Rand) string { return getRandValue(r, []string{"food", "fruit"}) }
// Vegetable will return a random vegetable name
func Vegetable() string { return vegetable(globalFaker.Rand) }
// Vegetable will return a random vegetable name
func (f *Faker) Vegetable() string { return vegetable(f.Rand) }
func vegetable(r *rand.Rand) string { return getRandValue(r, []string{"food", "vegetable"}) }
// Breakfast will return a random breakfast name
func Breakfast() string { return breakfast(globalFaker.Rand) }
// Breakfast will return a random breakfast name
func (f *Faker) Breakfast() string { return breakfast(f.Rand) }
func breakfast(r *rand.Rand) string {
v := getRandValue(r, []string{"food", "breakfast"})
return strings.ToUpper(v[:1]) + v[1:]
}
// Lunch will return a random lunch name
func Lunch() string { return lunch(globalFaker.Rand) }
// Lunch will return a random lunch name
func (f *Faker) Lunch() string { return lunch(f.Rand) }
func lunch(r *rand.Rand) string {
v := getRandValue(r, []string{"food", "lunch"})
return strings.ToUpper(v[:1]) + v[1:]
}
// Dinner will return a random dinner name
func Dinner() string { return dinner(globalFaker.Rand) }
// Dinner will return a random dinner name
func (f *Faker) Dinner() string { return dinner(f.Rand) }
func dinner(r *rand.Rand) string {
v := getRandValue(r, []string{"food", "dinner"})
return strings.ToUpper(v[:1]) + v[1:]
}
// Drink will return a random drink name
func Drink() string { return drink(globalFaker.Rand) }
// Drink will return a random drink name
func (f *Faker) Drink() string { return drink(f.Rand) }
func drink(r *rand.Rand) string {
v := getRandValue(r, []string{"food", "drink"})
return strings.ToUpper(v[:1]) + v[1:]
}
// Snack will return a random snack name
func Snack() string { return snack(globalFaker.Rand) }
// Snack will return a random snack name
func (f *Faker) Snack() string { return snack(f.Rand) }
func snack(r *rand.Rand) string {
v := getRandValue(r, []string{"food", "snack"})
return strings.ToUpper(v[:1]) + v[1:]
}
// Dessert will return a random dessert name
func Dessert() string { return dessert(globalFaker.Rand) }
// Dessert will return a random dessert name
func (f *Faker) Dessert() string { return dessert(f.Rand) }
func dessert(r *rand.Rand) string {
v := getRandValue(r, []string{"food", "dessert"})
return strings.ToUpper(v[:1]) + v[1:]
}
func addFoodLookup() {
AddFuncLookup("fruit", Info{
Display: "Fruit",
Category: "food",
Description: "Edible plant part, typically sweet, enjoyed as a natural snack or dessert",
Example: "Peach",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return fruit(r), nil
},
})
AddFuncLookup("vegetable", Info{
Display: "Vegetable",
Category: "food",
Description: "Edible plant or part of a plant, often used in savory cooking or salads",
Example: "Amaranth Leaves",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return vegetable(r), nil
},
})
AddFuncLookup("breakfast", Info{
Display: "Breakfast",
Category: "food",
Description: "First meal of the day, typically eaten in the morning",
Example: "Blueberry banana happy face pancakes",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return breakfast(r), nil
},
})
AddFuncLookup("lunch", Info{
Display: "Lunch",
Category: "food",
Description: "Midday meal, often lighter than dinner, eaten around noon",
Example: "No bake hersheys bar pie",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return lunch(r), nil
},
})
AddFuncLookup("dinner", Info{
Display: "Dinner",
Category: "food",
Description: "Evening meal, typically the day's main and most substantial meal",
Example: "Wild addicting dip",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return dinner(r), nil
},
})
AddFuncLookup("drink", Info{
Display: "Drink",
Category: "food",
Description: "Liquid consumed for hydration, pleasure, or nutritional benefits",
Example: "Soda",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return drink(r), nil
},
})
AddFuncLookup("snack", Info{
Display: "Snack",
Category: "food",
Description: "Random snack",
Example: "Small, quick food item eaten between meals",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return snack(r), nil
},
})
AddFuncLookup("dessert", Info{
Display: "Dessert",
Category: "food",
Description: "Sweet treat often enjoyed after a meal",
Example: "French napoleons",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return dessert(r), nil
},
})
}

102
vendor/github.com/brianvoe/gofakeit/v6/game.go generated vendored Normal file
View File

@ -0,0 +1,102 @@
package gofakeit
import (
"fmt"
"math/rand"
"strings"
)
// Gamertag will generate a random video game username
func Gamertag() string { return gamertag(globalFaker.Rand) }
// Gamertag will generate a random video game username
func (f *Faker) Gamertag() string { return gamertag(f.Rand) }
func gamertag(r *rand.Rand) string {
str := ""
num := number(r, 1, 4)
switch num {
case 1:
str = fmt.Sprintf("%s%ser", title(nounConcrete(r)), title(verbAction(r)))
case 2:
str = fmt.Sprintf("%s%s", title(adjectiveDescriptive(r)), title(animal(r)))
case 3:
str = fmt.Sprintf("%s%s", title(adjectiveDescriptive(r)), title(nounConcrete(r)))
case 4:
str = fmt.Sprintf("%s%s", title(fruit(r)), title(adjectiveDescriptive(r)))
}
// Randomly determine if we should add a number
if r.Intn(3) == 1 {
str += digitN(r, uint(number(r, 1, 3)))
}
// Remove any spaces
str = strings.Replace(str, " ", "", -1)
return str
}
// Dice will generate a random set of dice
func Dice(numDice uint, sides []uint) []uint { return dice(globalFaker.Rand, numDice, sides) }
// Dice will generate a random set of dice
func (f *Faker) Dice(numDice uint, sides []uint) []uint { return dice(f.Rand, numDice, sides) }
func dice(r *rand.Rand, numDice uint, sides []uint) []uint {
dice := make([]uint, numDice)
// If we dont have any sides well set the sides to 6
if len(sides) == 0 {
sides = []uint{6}
}
for i := range dice {
// If sides[i] doesnt exist use the first side
if len(sides)-1 < i {
dice[i] = uint(number(r, 1, int(sides[0])))
} else {
dice[i] = uint(number(r, 1, int(sides[i])))
}
}
return dice
}
func addGameLookup() {
AddFuncLookup("gamertag", Info{
Display: "Gamertag",
Category: "game",
Description: "User-selected online username or alias used for identification in games",
Example: "footinterpret63",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return gamertag(r), nil
},
})
AddFuncLookup("dice", Info{
Display: "Dice",
Category: "game",
Description: "Small, cube-shaped objects used in games of chance for random outcomes",
Example: "[5, 2, 3]",
Output: "[]uint",
Params: []Param{
{Field: "numdice", Display: "Number of Dice", Type: "uint", Default: "1", Description: "Number of dice to roll"},
{Field: "sides", Display: "Number of Sides", Type: "[]uint", Default: "[6]", Description: "Number of sides on each dice"},
},
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
numDice, err := info.GetUint(m, "numdice")
if err != nil {
return nil, err
}
sides, err := info.GetUintArray(m, "sides")
if err != nil {
return nil, err
}
return dice(r, numDice, sides), nil
},
})
}

589
vendor/github.com/brianvoe/gofakeit/v6/generate.go generated vendored Normal file
View File

@ -0,0 +1,589 @@
package gofakeit
import (
"encoding/json"
"errors"
"fmt"
"math"
"math/rand"
"regexp/syntax"
"strings"
)
// Generate fake information from given string.
// Replaceable values should be within {}
//
// Functions
// Ex: {firstname} - billy
// Ex: {sentence:3} - Record river mind.
// Ex: {number:1,10} - 4
// Ex: {uuid} - 590c1440-9888-45b0-bd51-a817ee07c3f2
//
// Letters/Numbers
// Ex: ### - 481 - random numbers
// Ex: ??? - fda - random letters
//
// For a complete list of runnable functions use FuncsLookup
func Generate(dataVal string) string { return generate(globalFaker.Rand, dataVal) }
// Generate fake information from given string.
// Replaceable values should be within {}
//
// Functions
// Ex: {firstname} - billy
// Ex: {sentence:3} - Record river mind.
// Ex: {number:1,10} - 4
// Ex: {uuid} - 590c1440-9888-45b0-bd51-a817ee07c3f2
//
// Letters/Numbers
// Ex: ### - 481 - random numbers
// Ex: ??? - fda - random letters
//
// For a complete list of runnable functions use FuncsLookup
func (f *Faker) Generate(dataVal string) string { return generate(f.Rand, dataVal) }
func generate(r *rand.Rand, dataVal string) string {
// Replace # with numbers and ? with letters
dataVal = replaceWithNumbers(r, dataVal)
dataVal = replaceWithLetters(r, dataVal)
// Check if string has any replaceable values
if !strings.Contains(dataVal, "{") && !strings.Contains(dataVal, "}") {
return dataVal
}
// Variables to identify the index in which it exists
startCurly := -1
startCurlyIgnore := []int{}
endCurly := -1
endCurlyIgnore := []int{}
// Loop through string characters
for i := 0; i < len(dataVal); i++ {
// Check for ignores if equal skip
shouldSkip := false
for _, igs := range startCurlyIgnore {
if i == igs {
shouldSkip = true
}
}
for _, ige := range endCurlyIgnore {
if i == ige {
shouldSkip = true
}
}
if shouldSkip {
continue
}
// Identify items between brackets. Ex: {firstname}
if string(dataVal[i]) == "{" {
startCurly = i
continue
}
if startCurly != -1 && string(dataVal[i]) == "}" {
endCurly = i
}
if startCurly == -1 || endCurly == -1 {
continue
}
// Get the value between brackets
fParts := dataVal[startCurly+1 : endCurly]
// Check if has params separated by :
fNameSplit := strings.SplitN(fParts, ":", 2)
fName := ""
fParams := ""
if len(fNameSplit) >= 1 {
fName = fNameSplit[0]
}
if len(fNameSplit) >= 2 {
fParams = fNameSplit[1]
}
// Check to see if its a replaceable lookup function
if info := GetFuncLookup(fName); info != nil {
// Get parameters, make sure params and the split both have values
mapParams := NewMapParams()
paramsLen := len(info.Params)
// If just one param and its a string simply just pass it
if paramsLen == 1 && info.Params[0].Type == "string" {
mapParams.Add(info.Params[0].Field, fParams)
} else if paramsLen > 0 && fParams != "" {
splitVals := funcLookupSplit(fParams)
mapParams = addSplitValsToMapParams(splitVals, info, mapParams)
}
if mapParams.Size() == 0 {
mapParams = nil
}
// Call function
fValue, err := info.Generate(r, mapParams, info)
if err != nil {
// If we came across an error just dont replace value
dataVal = strings.Replace(dataVal, "{"+fParts+"}", err.Error(), 1)
} else {
// Successfully found, run replace with new value
dataVal = strings.Replace(dataVal, "{"+fParts+"}", fmt.Sprintf("%v", fValue), 1)
}
// Reset the curly index back to -1 and reset ignores
startCurly = -1
startCurlyIgnore = []int{}
endCurly = -1
endCurlyIgnore = []int{}
i = -1 // Reset back to the start of the string
continue
}
// Couldnt find anything - mark curly brackets to skip and rerun
startCurlyIgnore = append(startCurlyIgnore, startCurly)
endCurlyIgnore = append(endCurlyIgnore, endCurly)
// Reset the curly index back to -1
startCurly = -1
endCurly = -1
i = -1 // Reset back to the start of the string
continue
}
return dataVal
}
// FixedWidthOptions defines values needed for csv generation
type FixedWidthOptions struct {
RowCount int `json:"row_count" xml:"row_count" fake:"{number:1,10}"`
Fields []Field `json:"fields" xml:"fields" fake:"{fields}"`
}
// FixedWidth generates an table of random data in fixed width format
// A nil FixedWidthOptions returns a randomly structured FixedWidth.
func FixedWidth(co *FixedWidthOptions) (string, error) { return fixeWidthFunc(globalFaker.Rand, co) }
// FixedWidth generates an table of random data in fixed width format
// A nil FixedWidthOptions returns a randomly structured FixedWidth.
func (f *Faker) FixedWidth(co *FixedWidthOptions) (string, error) { return fixeWidthFunc(f.Rand, co) }
// Function to generate a fixed width document
func fixeWidthFunc(r *rand.Rand, co *FixedWidthOptions) (string, error) {
// If we didn't get FixedWidthOptions, create a new random one
if co == nil {
co = &FixedWidthOptions{}
}
// Make sure you set a row count
if co.RowCount <= 0 {
co.RowCount = r.Intn(10) + 1
}
// Check fields
if len(co.Fields) <= 0 {
// Create random fields
co.Fields = []Field{
{Name: "Name", Function: "{firstname} {lastname}"},
{Name: "Email", Function: "email"},
{Name: "Password", Function: "password", Params: MapParams{"special": {"false"}, "space": {"false"}}},
}
}
data := [][]string{}
hasHeader := false
// Loop through fields, generate data and add to data array
for _, field := range co.Fields {
// Start new row
row := []string{}
// Add name to first value
if field.Name != "" {
hasHeader = true
}
row = append(row, field.Name)
// Get function
funcInfo := GetFuncLookup(field.Function)
var value any
if funcInfo == nil {
// Try to run the function through generate
for i := 0; i < co.RowCount; i++ {
row = append(row, generate(r, field.Function))
}
} else {
// Generate function value
var err error
for i := 0; i < co.RowCount; i++ {
value, err = funcInfo.Generate(r, &field.Params, funcInfo)
if err != nil {
value = ""
}
// Add value to row
row = append(row, anyToString(value))
}
}
// Add row to data
data = append(data, row)
}
var result strings.Builder
// Calculate column widths
colWidths := make([]int, len(data))
for i, row := range data {
for _, value := range row {
width := len(value) + 5
if width > colWidths[i] {
colWidths[i] = width
}
}
}
// Append table rows to the string, excluding the entire row if the first value is empty
for i := 0; i < len(data[0]); i++ {
if !hasHeader && i == 0 {
continue // Skip the entire column if the first value is empty
}
var resultRow strings.Builder
for j, row := range data {
resultRow.WriteString(fmt.Sprintf("%-*s", colWidths[j], row[i]))
}
// Trim trailing spaces
result.WriteString(strings.TrimRight(resultRow.String(), " "))
// Only add new line if not the last row
if i != len(data[0])-1 {
result.WriteString("\n")
}
}
return result.String(), nil
}
// Regex will generate a string based upon a RE2 syntax
func Regex(regexStr string) string { return regex(globalFaker.Rand, regexStr) }
// Regex will generate a string based upon a RE2 syntax
func (f *Faker) Regex(regexStr string) string { return regex(f.Rand, regexStr) }
func regex(r *rand.Rand, regexStr string) (gen string) {
re, err := syntax.Parse(regexStr, syntax.Perl)
if err != nil {
return "Could not parse regex string"
}
// Panic catch
defer func() {
if r := recover(); r != nil {
gen = fmt.Sprint(r)
return
}
}()
return regexGenerate(r, re, len(regexStr)*100)
}
func regexGenerate(ra *rand.Rand, re *syntax.Regexp, limit int) string {
if limit <= 0 {
panic("Length limit reached when generating output")
}
op := re.Op
switch op {
case syntax.OpNoMatch: // matches no strings
// Do Nothing
case syntax.OpEmptyMatch: // matches empty string
return ""
case syntax.OpLiteral: // matches Runes sequence
var b strings.Builder
for _, ru := range re.Rune {
b.WriteRune(ru)
}
return b.String()
case syntax.OpCharClass: // matches Runes interpreted as range pair list
// number of possible chars
sum := 0
for i := 0; i < len(re.Rune); i += 2 {
sum += int(re.Rune[i+1]-re.Rune[i]) + 1
if re.Rune[i+1] == 0x10ffff { // rune range end
sum = -1
break
}
}
// pick random char in range (inverse match group)
if sum == -1 {
chars := []uint8{}
for j := 0; j < len(allStr); j++ {
c := allStr[j]
// Check c in range
for i := 0; i < len(re.Rune); i += 2 {
if rune(c) >= re.Rune[i] && rune(c) <= re.Rune[i+1] {
chars = append(chars, c)
break
}
}
}
if len(chars) > 0 {
return string([]byte{chars[ra.Intn(len(chars))]})
}
}
r := ra.Intn(int(sum))
var ru rune
sum = 0
for i := 0; i < len(re.Rune); i += 2 {
gap := int(re.Rune[i+1]-re.Rune[i]) + 1
if sum+gap > r {
ru = re.Rune[i] + rune(r-sum)
break
}
sum += gap
}
return string(ru)
case syntax.OpAnyCharNotNL, syntax.OpAnyChar: // matches any character(and except newline)
return randCharacter(ra, allStr)
case syntax.OpBeginLine: // matches empty string at beginning of line
case syntax.OpEndLine: // matches empty string at end of line
case syntax.OpBeginText: // matches empty string at beginning of text
case syntax.OpEndText: // matches empty string at end of text
case syntax.OpWordBoundary: // matches word boundary `\b`
case syntax.OpNoWordBoundary: // matches word non-boundary `\B`
case syntax.OpCapture: // capturing subexpression with index Cap, optional name Name
return regexGenerate(ra, re.Sub0[0], limit)
case syntax.OpStar: // matches Sub[0] zero or more times
var b strings.Builder
for i := 0; i < number(ra, 0, 10); i++ {
for _, rs := range re.Sub {
b.WriteString(regexGenerate(ra, rs, limit-b.Len()))
}
}
return b.String()
case syntax.OpPlus: // matches Sub[0] one or more times
var b strings.Builder
for i := 0; i < number(ra, 1, 10); i++ {
for _, rs := range re.Sub {
b.WriteString(regexGenerate(ra, rs, limit-b.Len()))
}
}
return b.String()
case syntax.OpQuest: // matches Sub[0] zero or one times
var b strings.Builder
for i := 0; i < number(ra, 0, 1); i++ {
for _, rs := range re.Sub {
b.WriteString(regexGenerate(ra, rs, limit-b.Len()))
}
}
return b.String()
case syntax.OpRepeat: // matches Sub[0] at least Min times, at most Max (Max == -1 is no limit)
var b strings.Builder
count := 0
re.Max = int(math.Min(float64(re.Max), float64(10)))
if re.Max > re.Min {
count = ra.Intn(re.Max - re.Min + 1)
}
for i := 0; i < re.Min || i < (re.Min+count); i++ {
for _, rs := range re.Sub {
b.WriteString(regexGenerate(ra, rs, limit-b.Len()))
}
}
return b.String()
case syntax.OpConcat: // matches concatenation of Subs
var b strings.Builder
for _, rs := range re.Sub {
b.WriteString(regexGenerate(ra, rs, limit-b.Len()))
}
return b.String()
case syntax.OpAlternate: // matches alternation of Subs
return regexGenerate(ra, re.Sub[number(ra, 0, len(re.Sub)-1)], limit)
}
return ""
}
// Map will generate a random set of map data
func Map() map[string]any { return mapFunc(globalFaker.Rand) }
// Map will generate a random set of map data
func (f *Faker) Map() map[string]any { return mapFunc(f.Rand) }
func mapFunc(r *rand.Rand) map[string]any {
m := map[string]any{}
randWordType := func() string {
s := randomString(r, []string{"lorem", "bs", "job", "name", "address"})
switch s {
case "bs":
return bs(r)
case "job":
return jobTitle(r)
case "name":
return name(r)
case "address":
return street(r) + ", " + city(r) + ", " + state(r) + " " + zip(r)
}
return word(r)
}
randSlice := func() []string {
var sl []string
for ii := 0; ii < number(r, 3, 10); ii++ {
sl = append(sl, word(r))
}
return sl
}
for i := 0; i < number(r, 3, 10); i++ {
t := randomString(r, []string{"string", "int", "float", "slice", "map"})
switch t {
case "string":
m[word(r)] = randWordType()
case "int":
m[word(r)] = number(r, 1, 10000000)
case "float":
m[word(r)] = float32Range(r, 1, 1000000)
case "slice":
m[word(r)] = randSlice()
case "map":
mm := map[string]any{}
tt := randomString(r, []string{"string", "int", "float", "slice"})
switch tt {
case "string":
mm[word(r)] = randWordType()
case "int":
mm[word(r)] = number(r, 1, 10000000)
case "float":
mm[word(r)] = float32Range(r, 1, 1000000)
case "slice":
mm[word(r)] = randSlice()
}
m[word(r)] = mm
}
}
return m
}
func addGenerateLookup() {
AddFuncLookup("generate", Info{
Display: "Generate",
Category: "generate",
Description: "Random string generated from string value based upon available data sets",
Example: "{firstname} {lastname} {email} - Markus Moen markusmoen@pagac.net",
Output: "string",
Params: []Param{
{Field: "str", Display: "String", Type: "string", Description: "String value to generate from"},
},
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
str, err := info.GetString(m, "str")
if err != nil {
return nil, err
}
// Limit the length of the string passed
if len(str) > 1000 {
return nil, errors.New("string length is too large. limit to 1000 characters")
}
return generate(r, str), nil
},
})
AddFuncLookup("fixed_width", Info{
Display: "Fixed Width",
Category: "generate",
Description: "Fixed width rows of output data based on input fields",
Example: `Name Email Password Age
Markus Moen sylvanmraz@murphy.net 6VlvH6qqXc7g 13
Alayna Wuckert santinostanton@carroll.biz g7sLrS0gEwLO 46
Lura Lockman zacherykuhic@feil.name S8gV7Z64KlHG 12`,
Output: "[]byte",
ContentType: "text/plain",
Params: []Param{
{Field: "rowcount", Display: "Row Count", Type: "int", Default: "10", Description: "Number of rows"},
{Field: "fields", Display: "Fields", Type: "[]Field", Description: "Fields name, function and params"},
},
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
co := FixedWidthOptions{}
rowCount, err := info.GetInt(m, "rowcount")
if err != nil {
return nil, err
}
co.RowCount = rowCount
fields, _ := info.GetStringArray(m, "fields")
// Check to make sure fields has length
if len(fields) > 0 {
co.Fields = make([]Field, len(fields))
for i, f := range fields {
// Unmarshal fields string into fields array
err = json.Unmarshal([]byte(f), &co.Fields[i])
if err != nil {
return nil, err
}
}
} else {
return nil, errors.New("missing fields")
}
out, err := fixeWidthFunc(r, &co)
if err != nil {
return nil, err
}
return out, nil
},
})
AddFuncLookup("regex", Info{
Display: "Regex",
Category: "generate",
Description: "Pattern-matching tool used in text processing to search and manipulate strings",
Example: "[abcdef]{5} - affec",
Output: "string",
Params: []Param{
{Field: "str", Display: "String", Type: "string", Description: "Regex RE2 syntax string"},
},
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
str, err := info.GetString(m, "str")
if err != nil {
return nil, err
}
// Limit the length of the string passed
if len(str) > 500 {
return nil, errors.New("string length is too large. limit to 500 characters")
}
return regex(r, str), nil
},
})
AddFuncLookup("map", Info{
Display: "Map",
Category: "generate",
Description: "Data structure that stores key-value pairs",
Example: `{
"software": 7518355,
"that": ["despite", "pack", "whereas", "recently", "there", "anyone", "time", "read"],
"use": 683598,
"whom": "innovate",
"yourselves": 1987784
}`,
Output: "map[string]any",
ContentType: "application/json",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return mapFunc(r), nil
},
})
}

136
vendor/github.com/brianvoe/gofakeit/v6/hacker.go generated vendored Normal file
View File

@ -0,0 +1,136 @@
package gofakeit
import (
"math/rand"
"strings"
)
// HackerPhrase will return a random hacker sentence
func HackerPhrase() string { return hackerPhrase(globalFaker.Rand) }
// HackerPhrase will return a random hacker sentence
func (f *Faker) HackerPhrase() string { return hackerPhrase(f.Rand) }
func hackerPhrase(r *rand.Rand) string {
words := strings.Split(generate(r, getRandValue(r, []string{"hacker", "phrase"})), " ")
words[0] = strings.ToUpper(words[0][0:1]) + words[0][1:]
return strings.Join(words, " ")
}
// HackerAbbreviation will return a random hacker abbreviation
func HackerAbbreviation() string { return hackerAbbreviation(globalFaker.Rand) }
// HackerAbbreviation will return a random hacker abbreviation
func (f *Faker) HackerAbbreviation() string { return hackerAbbreviation(f.Rand) }
func hackerAbbreviation(r *rand.Rand) string {
return getRandValue(r, []string{"hacker", "abbreviation"})
}
// HackerAdjective will return a random hacker adjective
func HackerAdjective() string { return hackerAdjective(globalFaker.Rand) }
// HackerAdjective will return a random hacker adjective
func (f *Faker) HackerAdjective() string { return hackerAdjective(f.Rand) }
func hackerAdjective(r *rand.Rand) string {
return getRandValue(r, []string{"hacker", "adjective"})
}
// HackerNoun will return a random hacker noun
func HackerNoun() string { return hackerNoun(globalFaker.Rand) }
// HackerNoun will return a random hacker noun
func (f *Faker) HackerNoun() string { return hackerNoun(f.Rand) }
func hackerNoun(r *rand.Rand) string {
return getRandValue(r, []string{"hacker", "noun"})
}
// HackerVerb will return a random hacker verb
func HackerVerb() string { return hackerVerb(globalFaker.Rand) }
// HackerVerb will return a random hacker verb
func (f *Faker) HackerVerb() string { return hackerVerb(f.Rand) }
func hackerVerb(r *rand.Rand) string {
return getRandValue(r, []string{"hacker", "verb"})
}
// HackeringVerb will return a random hacker ingverb
func HackeringVerb() string { return hackeringVerb(globalFaker.Rand) }
// HackeringVerb will return a random hacker ingverb
func (f *Faker) HackeringVerb() string { return hackeringVerb(f.Rand) }
func hackeringVerb(r *rand.Rand) string {
return getRandValue(r, []string{"hacker", "ingverb"})
}
func addHackerLookup() {
AddFuncLookup("hackerphrase", Info{
Display: "Hacker Phrase",
Category: "hacker",
Description: "Informal jargon and slang used in the hacking and cybersecurity community",
Example: "If we calculate the program, we can get to the AI pixel through the redundant XSS matrix!",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return hackerPhrase(r), nil
},
})
AddFuncLookup("hackerabbreviation", Info{
Display: "Hacker Abbreviation",
Category: "hacker",
Description: "Abbreviations and acronyms commonly used in the hacking and cybersecurity community",
Example: "ADP",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return hackerAbbreviation(r), nil
},
})
AddFuncLookup("hackeradjective", Info{
Display: "Hacker Adjective",
Category: "hacker",
Description: "Adjectives describing terms often associated with hackers and cybersecurity experts",
Example: "wireless",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return hackerAdjective(r), nil
},
})
AddFuncLookup("hackernoun", Info{
Display: "Hacker Noun",
Category: "hacker",
Description: "Noun representing an element, tool, or concept within the realm of hacking and cybersecurity",
Example: "driver",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return hackerNoun(r), nil
},
})
AddFuncLookup("hackerverb", Info{
Display: "Hacker Verb",
Category: "hacker",
Description: "Verbs associated with actions and activities in the field of hacking and cybersecurity",
Example: "synthesize",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return hackerVerb(r), nil
},
})
AddFuncLookup("hackeringverb", Info{
Display: "Hackering Verb",
Category: "hacker",
Description: "Verb describing actions and activities related to hacking, often involving computer systems and security",
Example: "connecting",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return hackeringVerb(r), nil
},
})
}

400
vendor/github.com/brianvoe/gofakeit/v6/helpers.go generated vendored Normal file
View File

@ -0,0 +1,400 @@
package gofakeit
import (
crand "crypto/rand"
"encoding/binary"
"encoding/json"
"fmt"
"math"
"math/rand"
"reflect"
"strings"
"unicode"
"github.com/brianvoe/gofakeit/v6/data"
)
const lowerStr = "abcdefghijklmnopqrstuvwxyz"
const upperStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
const numericStr = "0123456789"
const specialStr = "@#$%&?|!(){}<>=*+-_:;,."
const specialSafeStr = "@#$&?!-_*."
const spaceStr = " "
const allStr = lowerStr + upperStr + numericStr + specialStr + spaceStr
const vowels = "aeiou"
const hashtag = '#'
const questionmark = '?'
const dash = '-'
const base58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
const minUint = 0
const maxUint = ^uint(0)
const minInt = -maxInt - 1
const maxInt = int(^uint(0) >> 1)
// Seed will set the global random value. Setting seed to 0 will use crypto/rand
func Seed(seed int64) {
if seed == 0 {
binary.Read(crand.Reader, binary.BigEndian, &seed)
globalFaker.Rand.Seed(seed)
} else {
globalFaker.Rand.Seed(seed)
}
}
// Check if in lib
func dataCheck(dataVal []string) bool {
var checkOk bool
if len(dataVal) == 2 {
_, checkOk = data.Data[dataVal[0]]
if checkOk {
_, checkOk = data.Data[dataVal[0]][dataVal[1]]
}
}
return checkOk
}
// Get Random Value
func getRandValue(r *rand.Rand, dataVal []string) string {
if !dataCheck(dataVal) {
return ""
}
return data.Data[dataVal[0]][dataVal[1]][r.Intn(len(data.Data[dataVal[0]][dataVal[1]]))]
}
// Replace # with numbers
func replaceWithNumbers(r *rand.Rand, str string) string {
if str == "" {
return str
}
bytestr := []byte(str)
for i := 0; i < len(bytestr); i++ {
if bytestr[i] == hashtag {
bytestr[i] = byte(randDigit(r))
}
}
if bytestr[0] == '0' {
bytestr[0] = byte(r.Intn(8)+1) + '0'
}
return string(bytestr)
}
// Replace ? with ASCII lowercase letters
func replaceWithLetters(r *rand.Rand, str string) string {
if str == "" {
return str
}
bytestr := []byte(str)
for i := 0; i < len(bytestr); i++ {
if bytestr[i] == questionmark {
bytestr[i] = byte(randLetter(r))
}
}
return string(bytestr)
}
// Replace ? with ASCII lowercase letters between a and f
func replaceWithHexLetters(r *rand.Rand, str string) string {
if str == "" {
return str
}
bytestr := []byte(str)
for i := 0; i < len(bytestr); i++ {
if bytestr[i] == questionmark {
bytestr[i] = byte(randHexLetter(r))
}
}
return string(bytestr)
}
// Generate random lowercase ASCII letter
func randLetter(r *rand.Rand) rune {
allLetters := upperStr + lowerStr
return rune(allLetters[r.Intn(len(allLetters))])
}
func randCharacter(r *rand.Rand, s string) string {
return string(s[r.Int63()%int64(len(s))])
}
// Generate random lowercase ASCII letter between a and f
func randHexLetter(r *rand.Rand) rune {
return rune(byte(r.Intn(6)) + 'a')
}
// Generate random ASCII digit
func randDigit(r *rand.Rand) rune {
return rune(byte(r.Intn(10)) + '0')
}
// Generate random integer between min and max
func randIntRange(r *rand.Rand, min, max int) int {
// If they pass in the same number, just return that number
if min == max {
return min
}
// If they pass in a min that is bigger than max, swap them
if min > max {
ogmin := min
min = max
max = ogmin
}
// Figure out if the min/max numbers calculation
// would cause a panic in the Int63() function.
if max-min+1 > 0 {
return min + int(r.Int63n(int64(max-min+1)))
}
// Loop through the range until we find a number that fits
for {
v := int(r.Uint64())
if (v >= min) && (v <= max) {
return v
}
}
}
// Generate random uint between min and max
func randUintRange(r *rand.Rand, min, max uint) uint {
// If they pass in the same number, just return that number
if min == max {
return min
}
// If they pass in a min that is bigger than max, swap them
if min > max {
ogmin := min
min = max
max = ogmin
}
// Figure out if the min/max numbers calculation
// would cause a panic in the Int63() function.
if int(max)-int(min)+1 > 0 {
return uint(r.Intn(int(max)-int(min)+1) + int(min))
}
// Loop through the range until we find a number that fits
for {
v := uint(r.Uint64())
if (v >= min) && (v <= max) {
return v
}
}
}
func toFixed(num float64, precision int) float64 {
output := math.Pow(10, float64(precision))
return float64(math.Floor(num*output)) / output
}
func equalSliceString(a, b []string) bool {
sizeA, sizeB := len(a), len(b)
if sizeA != sizeB {
return false
}
for i, va := range a {
vb := b[i]
if va != vb {
return false
}
}
return true
}
func equalSliceInt(a, b []int) bool {
sizeA, sizeB := len(a), len(b)
if sizeA != sizeB {
return false
}
for i, va := range a {
vb := b[i]
if va != vb {
return false
}
}
return true
}
func equalSliceInterface(a, b []any) bool {
sizeA, sizeB := len(a), len(b)
if sizeA != sizeB {
return false
}
for i, va := range a {
if !reflect.DeepEqual(va, b[i]) {
return false
}
}
return true
}
func stringInSlice(a string, list []string) bool {
for _, b := range list {
if b == a {
return true
}
}
return false
}
func anyToString(a any) string {
if a == nil {
return ""
}
// If it's a slice of bytes or struct, unmarshal it into an interface
if bytes, ok := a.([]byte); ok {
return string(bytes)
}
// If it's a struct, map, or slice, convert to JSON
switch reflect.TypeOf(a).Kind() {
case reflect.Struct, reflect.Map, reflect.Slice:
b, err := json.Marshal(a)
if err == nil {
return string(b)
}
}
return fmt.Sprintf("%v", a)
}
// Title returns a copy of the string s with all Unicode letters that begin words
// mapped to their Unicode title case
func title(s string) string {
// isSeparator reports whether the rune could mark a word boundary
isSeparator := func(r rune) bool {
// ASCII alphanumerics and underscore are not separators
if r <= 0x7F {
switch {
case '0' <= r && r <= '9':
return false
case 'a' <= r && r <= 'z':
return false
case 'A' <= r && r <= 'Z':
return false
case r == '_':
return false
}
return true
}
// Letters and digits are not separators
if unicode.IsLetter(r) || unicode.IsDigit(r) {
return false
}
// Otherwise, all we can do for now is treat spaces as separators.
return unicode.IsSpace(r)
}
prev := ' '
return strings.Map(
func(r rune) rune {
if isSeparator(prev) {
prev = r
return unicode.ToTitle(r)
}
prev = r
return r
},
s)
}
func funcLookupSplit(str string) []string {
out := []string{}
for str != "" {
if strings.HasPrefix(str, "[") {
startIndex := strings.Index(str, "[")
endIndex := strings.Index(str, "]")
val := str[(startIndex) : endIndex+1]
out = append(out, strings.TrimSpace(val))
str = strings.Replace(str, val, "", 1)
// Trim off comma if it has it
if strings.HasPrefix(str, ",") {
str = strings.Replace(str, ",", "", 1)
}
} else {
strSplit := strings.SplitN(str, ",", 2)
strSplitLen := len(strSplit)
if strSplitLen >= 1 {
out = append(out, strings.TrimSpace(strSplit[0]))
}
if strSplitLen >= 2 {
str = strSplit[1]
} else {
str = ""
}
}
}
return out
}
// Used for parsing the tag in a struct
func parseNameAndParamsFromTag(tag string) (string, string) {
// Trim the curly on the beginning and end
tag = strings.TrimLeft(tag, "{")
tag = strings.TrimRight(tag, "}")
// Check if has params separated by :
fNameSplit := strings.SplitN(tag, ":", 2)
fName := ""
fParams := ""
if len(fNameSplit) >= 1 {
fName = fNameSplit[0]
}
if len(fNameSplit) >= 2 {
fParams = fNameSplit[1]
}
return fName, fParams
}
// Used for parsing map params
func parseMapParams(info *Info, fParams string) *MapParams {
// Get parameters, make sure params and the split both have values
mapParams := NewMapParams()
paramsLen := len(info.Params)
// If just one param and its a string simply just pass it
if paramsLen == 1 && info.Params[0].Type == "string" {
mapParams.Add(info.Params[0].Field, fParams)
} else if paramsLen > 0 && fParams != "" {
splitVals := funcLookupSplit(fParams)
mapParams = addSplitValsToMapParams(splitVals, info, mapParams)
}
if mapParams.Size() > 0 {
return mapParams
} else {
return nil
}
}
// Used for splitting the values
func addSplitValsToMapParams(splitVals []string, info *Info, mapParams *MapParams) *MapParams {
for ii := 0; ii < len(splitVals); ii++ {
if len(info.Params)-1 >= ii {
if strings.HasPrefix(splitVals[ii], "[") {
lookupSplits := funcLookupSplit(strings.TrimRight(strings.TrimLeft(splitVals[ii], "["), "]"))
for _, v := range lookupSplits {
mapParams.Add(info.Params[ii].Field, v)
}
} else {
mapParams.Add(info.Params[ii].Field, splitVals[ii])
}
}
}
return mapParams
}

131
vendor/github.com/brianvoe/gofakeit/v6/hipster.go generated vendored Normal file
View File

@ -0,0 +1,131 @@
package gofakeit
import (
"errors"
"math/rand"
)
// HipsterWord will return a single hipster word
func HipsterWord() string { return hipsterWord(globalFaker.Rand) }
// HipsterWord will return a single hipster word
func (f *Faker) HipsterWord() string { return hipsterWord(f.Rand) }
func hipsterWord(r *rand.Rand) string { return getRandValue(r, []string{"hipster", "word"}) }
// HipsterSentence will generate a random sentence
func HipsterSentence(wordCount int) string { return hipsterSentence(globalFaker.Rand, wordCount) }
// HipsterSentence will generate a random sentence
func (f *Faker) HipsterSentence(wordCount int) string { return hipsterSentence(f.Rand, wordCount) }
func hipsterSentence(r *rand.Rand, wordCount int) string {
return sentenceGen(r, wordCount, hipsterWord)
}
// HipsterParagraph will generate a random paragraphGenerator
// Set Paragraph Count
// Set Sentence Count
// Set Word Count
// Set Paragraph Separator
func HipsterParagraph(paragraphCount int, sentenceCount int, wordCount int, separator string) string {
return hipsterParagraph(globalFaker.Rand, paragraphCount, sentenceCount, wordCount, separator)
}
// HipsterParagraph will generate a random paragraphGenerator
// Set Paragraph Count
// Set Sentence Count
// Set Word Count
// Set Paragraph Separator
func (f *Faker) HipsterParagraph(paragraphCount int, sentenceCount int, wordCount int, separator string) string {
return hipsterParagraph(f.Rand, paragraphCount, sentenceCount, wordCount, separator)
}
func hipsterParagraph(r *rand.Rand, paragraphCount int, sentenceCount int, wordCount int, separator string) string {
return paragraphGen(r, paragrapOptions{paragraphCount, sentenceCount, wordCount, separator}, hipsterSentence)
}
func addHipsterLookup() {
AddFuncLookup("hipsterword", Info{
Display: "Hipster Word",
Category: "hipster",
Description: "Trendy and unconventional vocabulary used by hipsters to express unique cultural preferences",
Example: "microdosing",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return hipsterWord(r), nil
},
})
AddFuncLookup("hipstersentence", Info{
Display: "Hipster Sentence",
Category: "hipster",
Description: "Sentence showcasing the use of trendy and unconventional vocabulary associated with hipster culture",
Example: "Microdosing roof chia echo pickled.",
Output: "string",
Params: []Param{
{Field: "wordcount", Display: "Word Count", Type: "int", Default: "5", Description: "Number of words in a sentence"},
},
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
wordCount, err := info.GetInt(m, "wordcount")
if err != nil {
return nil, err
}
if wordCount <= 0 || wordCount > 50 {
return nil, errors.New("invalid word count, must be greater than 0, less than 50")
}
return hipsterSentence(r, wordCount), nil
},
})
AddFuncLookup("hipsterparagraph", Info{
Display: "Hipster Paragraph",
Category: "hipster",
Description: "Paragraph showcasing the use of trendy and unconventional vocabulary associated with hipster culture",
Example: `Microdosing roof chia echo pickled meditation cold-pressed raw denim fingerstache normcore sriracha pork belly. Wolf try-hard pop-up blog tilde hashtag health butcher waistcoat paleo portland vinegar. Microdosing sartorial blue bottle slow-carb freegan five dollar toast you probably haven't heard of them asymmetrical chia farm-to-table narwhal banjo. Gluten-free blog authentic literally synth vinyl meh ethical health fixie banh mi Yuccie. Try-hard drinking squid seitan cray VHS echo chillwave hammock kombucha food truck sustainable.
Pug bushwick hella tote bag cliche direct trade waistcoat yr waistcoat knausgaard pour-over master. Pitchfork jean shorts franzen flexitarian distillery hella meggings austin knausgaard crucifix wolf heirloom. Crucifix food truck you probably haven't heard of them trust fund fixie gentrify pitchfork stumptown mlkshk umami chambray blue bottle. 3 wolf moon swag +1 biodiesel knausgaard semiotics taxidermy meh artisan hoodie +1 blue bottle. Fashion axe forage mixtape Thundercats pork belly whatever 90's beard selfies chambray cred mlkshk.
Shabby chic typewriter VHS readymade lo-fi bitters PBR&B gentrify lomo raw denim freegan put a bird on it. Raw denim cliche dreamcatcher pug fixie park trust fund migas fingerstache sriracha +1 mustache. Tilde shoreditch kickstarter franzen dreamcatcher green juice mustache neutra polaroid stumptown organic schlitz. Flexitarian ramps chicharrones kogi lo-fi mustache tilde forage street church-key williamsburg taxidermy. Chia mustache plaid mumblecore squid slow-carb disrupt Thundercats goth shoreditch master direct trade.`,
Output: "string",
Params: []Param{
{Field: "paragraphcount", Display: "Paragraph Count", Type: "int", Default: "2", Description: "Number of paragraphs"},
{Field: "sentencecount", Display: "Sentence Count", Type: "int", Default: "2", Description: "Number of sentences in a paragraph"},
{Field: "wordcount", Display: "Word Count", Type: "int", Default: "5", Description: "Number of words in a sentence"},
{Field: "paragraphseparator", Display: "Paragraph Separator", Type: "string", Default: "<br />", Description: "String value to add between paragraphs"},
},
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
paragraphCount, err := info.GetInt(m, "paragraphcount")
if err != nil {
return nil, err
}
if paragraphCount <= 0 || paragraphCount > 20 {
return nil, errors.New("invalid paragraph count, must be greater than 0, less than 20")
}
sentenceCount, err := info.GetInt(m, "sentencecount")
if err != nil {
return nil, err
}
if sentenceCount <= 0 || sentenceCount > 20 {
return nil, errors.New("invalid sentence count, must be greater than 0, less than 20")
}
wordCount, err := info.GetInt(m, "wordcount")
if err != nil {
return nil, err
}
if wordCount <= 0 || wordCount > 50 {
return nil, errors.New("invalid word count, must be greater than 0, less than 50")
}
paragraphSeparator, err := info.GetString(m, "paragraphseparator")
if err != nil {
return nil, err
}
return hipsterParagraph(r, paragraphCount, sentenceCount, wordCount, paragraphSeparator), nil
},
})
}

175
vendor/github.com/brianvoe/gofakeit/v6/html.go generated vendored Normal file
View File

@ -0,0 +1,175 @@
package gofakeit
import (
"errors"
"math/rand"
"strconv"
"strings"
"github.com/brianvoe/gofakeit/v6/data"
)
// InputName will return a random input field name
func InputName() string {
return inputName(globalFaker.Rand)
}
// InputName will return a random input field name
func (f *Faker) InputName() string {
return inputName(f.Rand)
}
func inputName(r *rand.Rand) string {
return getRandValue(r, []string{"html", "input_name"})
}
type SVGOptions struct {
Height int
Width int
Type string
Colors []string
}
// Generate a random svg generator
func Svg(options *SVGOptions) string { return svg(globalFaker.Rand, options) }
// Generate a random svg generator
func (f *Faker) Svg(options *SVGOptions) string { return svg(f.Rand, options) }
func svg(r *rand.Rand, options *SVGOptions) string {
// If options is nil, set it to empty struct
if options == nil {
options = &SVGOptions{}
}
// If options height and weight is not set, set it to random number between 100 and 500
if options.Width == 0 {
options.Width = number(r, 100, 500)
}
widthStr := strconv.Itoa(options.Width)
if options.Height == 0 {
options.Height = number(r, 100, 500)
}
heightStr := strconv.Itoa(options.Height)
// Check if type is set, if not set to random type
if options.Type == "" {
options.Type = randomString(r, data.GetSubData("html", "svg"))
}
// If the colors are not set, set it to a set of nice colors
if len(options.Colors) == 0 {
options.Colors = niceColors(r)
}
// Start svg string
svgStr := `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ` + widthStr + ` ` + heightStr + `" width="` + widthStr + `" height="` + heightStr + `">`
// Add a rect for the background
svgStr += `<rect x="0" y="0" width="100%" height="100%" fill="` + randomString(r, options.Colors) + `" />`
// Add a random number of shapes
for i := 0; i < number(r, 10, 20); i++ {
// Add a random shape
switch options.Type {
case "rect":
svgStr += `<rect x="` + strconv.Itoa(number(r, 0, options.Width)) + `" y="` + strconv.Itoa(number(r, 0, options.Height)) + `" width="` + strconv.Itoa(number(r, 0, options.Width)) + `" height="` + strconv.Itoa(number(r, 0, options.Height)) + `" fill="` + randomString(r, options.Colors) + `" />`
case "circle":
svgStr += `<circle cx="` + strconv.Itoa(number(r, 0, options.Width)) + `" cy="` + strconv.Itoa(number(r, 0, options.Height)) + `" r="` + strconv.Itoa(number(r, 0, options.Width)) + `" fill="` + randomString(r, options.Colors) + `" />`
case "ellipse":
svgStr += `<ellipse cx="` + strconv.Itoa(number(r, 0, options.Width)) + `" cy="` + strconv.Itoa(number(r, 0, options.Height)) + `" rx="` + strconv.Itoa(number(r, 0, options.Width)) + `" ry="` + strconv.Itoa(number(r, 0, options.Height)) + `" fill="` + randomString(r, options.Colors) + `" />`
case "line":
svgStr += `<line x1="` + strconv.Itoa(number(r, 0, options.Width)) + `" y1="` + strconv.Itoa(number(r, 0, options.Height)) + `" x2="` + strconv.Itoa(number(r, 0, options.Width)) + `" y2="` + strconv.Itoa(number(r, 0, options.Height)) + `" stroke="` + randomString(r, options.Colors) + `" />`
case "polyline":
svgStr += `<polyline points="` + strconv.Itoa(number(r, 0, options.Width)) + `,` + strconv.Itoa(number(r, 0, options.Height)) + ` ` + strconv.Itoa(number(r, 0, options.Width)) + `,` + strconv.Itoa(number(r, 0, options.Height)) + ` ` + strconv.Itoa(number(r, 0, options.Width)) + `,` + strconv.Itoa(number(r, 0, options.Height)) + `" fill="` + randomString(r, options.Colors) + `" />`
case "polygon":
svgStr += `<polygon points="` + strconv.Itoa(number(r, 0, options.Width)) + `,` + strconv.Itoa(number(r, 0, options.Height)) + ` ` + strconv.Itoa(number(r, 0, options.Width)) + `,` + strconv.Itoa(number(r, 0, options.Height)) + ` ` + strconv.Itoa(number(r, 0, options.Width)) + `,` + strconv.Itoa(number(r, 0, options.Height)) + `" fill="` + randomString(r, options.Colors) + `" />`
}
}
// End svg string
svgStr += `</svg>`
return svgStr
}
func addHtmlLookup() {
AddFuncLookup("inputname", Info{
Display: "Input Name",
Category: "html",
Description: "Attribute used to define the name of an input element in web forms",
Example: "first_name",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return inputName(r), nil
},
})
AddFuncLookup("svg", Info{
Display: "Image SVG",
Category: "html",
Description: "Scalable Vector Graphics used to display vector images in web content",
Example: `<svg width="369" height="289">
<rect fill="#4f2958" />
<polygon points="382,87 418,212 415,110" fill="#fffbb7" />
</svg>`,
Output: "string",
ContentType: "image/svg+xml",
Params: []Param{
{Field: "width", Display: "Width", Type: "int", Default: "500", Description: "Width in px"},
{Field: "height", Display: "Height", Type: "int", Default: "500", Description: "Height in px"},
{Field: "type", Display: "Type", Type: "string", Optional: true, Options: data.GetSubData("html", "svg"), Description: "Sub child element type"},
{Field: "colors", Display: "Colors", Type: "[]string", Optional: true, Description: "Hex or RGB array of colors to use"},
},
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
// Setup new options
options := SVGOptions{}
var err error
options.Width, err = info.GetInt(m, "width")
if err != nil {
return nil, err
}
if options.Width < 10 || options.Width >= 1000 {
return nil, errors.New("invalid image width, must be greater than 10, less than 1000")
}
options.Height, err = info.GetInt(m, "height")
if err != nil {
return nil, err
}
if options.Height < 10 || options.Height >= 1000 {
return nil, errors.New("invalid image height, must be greater than 10, less than 1000")
}
options.Type, err = info.GetString(m, "type")
svgData := data.GetSubData("html", "svg")
if err != nil {
return nil, err
}
// If type is empty, set with random type
if options.Type == "" {
options.Type = randomString(r, svgData)
}
// If not in date html svg type array, return error
if !stringInSlice(options.Type, svgData) {
return nil, errors.New("invalid svg type, must be one of " + strings.Join(svgData, ","))
}
// Get colors
options.Colors, err = info.GetStringArray(m, "colors")
if err != nil {
return nil, err
}
// If colors is empty, set with random colors
if len(options.Colors) == 0 {
options.Colors = niceColors(r)
}
return svg(r, &options), nil
},
})
}

165
vendor/github.com/brianvoe/gofakeit/v6/image.go generated vendored Normal file
View File

@ -0,0 +1,165 @@
package gofakeit
import (
"bytes"
"errors"
img "image"
imgCol "image/color"
"image/jpeg"
"image/png"
"math/rand"
"strconv"
)
// ImageURL will generate a random Image Based Upon Height And Width. https://picsum.photos/
func ImageURL(width int, height int) string { return imageURL(globalFaker.Rand, width, height) }
// ImageURL will generate a random Image Based Upon Height And Width. https://picsum.photos/
func (f *Faker) ImageURL(width int, height int) string { return imageURL(f.Rand, width, height) }
func imageURL(r *rand.Rand, width int, height int) string {
return "https://picsum.photos/" + strconv.Itoa(width) + "/" + strconv.Itoa(height)
}
// Image generates a random rgba image
func Image(width int, height int) *img.RGBA { return image(globalFaker.Rand, width, height) }
// Image generates a random rgba image
func (f *Faker) Image(width int, height int) *img.RGBA { return image(f.Rand, width, height) }
func image(r *rand.Rand, width int, height int) *img.RGBA {
upLeft := img.Point{0, 0}
lowRight := img.Point{width, height}
img := img.NewRGBA(img.Rectangle{upLeft, lowRight})
// Set color for each pixel
for x := 0; x < width; x++ {
for y := 0; y < height; y++ {
img.Set(x, y, imgCol.RGBA{uint8(number(r, 0, 255)), uint8(number(r, 0, 255)), uint8(number(r, 0, 255)), 0xff})
}
}
return img
}
// ImageJpeg generates a random rgba jpeg image
func ImageJpeg(width int, height int) []byte { return imageJpeg(globalFaker.Rand, width, height) }
// ImageJpeg generates a random rgba jpeg image
func (f *Faker) ImageJpeg(width int, height int) []byte { return imageJpeg(f.Rand, width, height) }
func imageJpeg(r *rand.Rand, width int, height int) []byte {
buf := new(bytes.Buffer)
jpeg.Encode(buf, image(r, width, height), nil)
return buf.Bytes()
}
// ImagePng generates a random rgba png image
func ImagePng(width int, height int) []byte { return imagePng(globalFaker.Rand, width, height) }
// ImagePng generates a random rgba png image
func (f *Faker) ImagePng(width int, height int) []byte { return imagePng(f.Rand, width, height) }
func imagePng(r *rand.Rand, width int, height int) []byte {
buf := new(bytes.Buffer)
png.Encode(buf, image(r, width, height))
return buf.Bytes()
}
func addImageLookup() {
AddFuncLookup("imageurl", Info{
Display: "Image URL",
Category: "image",
Description: "Web address pointing to an image file that can be accessed and displayed online",
Example: "https://picsum.photos/500/500",
Output: "string",
Params: []Param{
{Field: "width", Display: "Width", Type: "int", Default: "500", Description: "Image width in px"},
{Field: "height", Display: "Height", Type: "int", Default: "500", Description: "Image height in px"},
},
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
width, err := info.GetInt(m, "width")
if err != nil {
return nil, err
}
if width < 10 || width >= 1000 {
return nil, errors.New("invalid image width, must be greater than 10, less than 1000")
}
height, err := info.GetInt(m, "height")
if err != nil {
return nil, err
}
if height < 10 || height >= 1000 {
return nil, errors.New("invalid image height, must be greater than 10, less than 1000")
}
return imageURL(r, width, height), nil
},
})
AddFuncLookup("imagejpeg", Info{
Display: "Image JPEG",
Category: "image",
Description: "Image file format known for its efficient compression and compatibility",
Example: "file.jpeg - bytes",
Output: "[]byte",
ContentType: "image/jpeg",
Params: []Param{
{Field: "width", Display: "Width", Type: "int", Default: "500", Description: "Image width in px"},
{Field: "height", Display: "Height", Type: "int", Default: "500", Description: "Image height in px"},
},
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
width, err := info.GetInt(m, "width")
if err != nil {
return nil, err
}
if width < 10 || width >= 1000 {
return nil, errors.New("invalid image width, must be greater than 10, less than 1000")
}
height, err := info.GetInt(m, "height")
if err != nil {
return nil, err
}
if height < 10 || height >= 1000 {
return nil, errors.New("invalid image height, must be greater than 10, less than 1000")
}
return imageJpeg(r, width, height), nil
},
})
AddFuncLookup("imagepng", Info{
Display: "Image PNG",
Category: "image",
Description: "Image file format known for its lossless compression and support for transparency",
Example: "file.png - bytes",
Output: "[]byte",
ContentType: "image/png",
Params: []Param{
{Field: "width", Display: "Width", Type: "int", Default: "500", Description: "Image width in px"},
{Field: "height", Display: "Height", Type: "int", Default: "500", Description: "Image height in px"},
},
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
width, err := info.GetInt(m, "width")
if err != nil {
return nil, err
}
if width < 10 || width >= 1000 {
return nil, errors.New("invalid image width, must be greater than 10, less than 1000")
}
height, err := info.GetInt(m, "height")
if err != nil {
return nil, err
}
if height < 10 || height >= 1000 {
return nil, errors.New("invalid image height, must be greater than 10, less than 1000")
}
return imagePng(r, width, height), nil
},
})
}

441
vendor/github.com/brianvoe/gofakeit/v6/internet.go generated vendored Normal file
View File

@ -0,0 +1,441 @@
package gofakeit
import (
"fmt"
"math/rand"
"strconv"
"strings"
"github.com/brianvoe/gofakeit/v6/data"
)
// DomainName will generate a random url domain name
func DomainName() string { return domainName(globalFaker.Rand) }
// DomainName will generate a random url domain name
func (f *Faker) DomainName() string { return domainName(f.Rand) }
func domainName(r *rand.Rand) string {
name := strings.Replace(strings.ToLower(jobDescriptor(r)+bs(r)), " ", "", -1)
return fmt.Sprintf("%s.%s", name, domainSuffix(r))
}
// DomainSuffix will generate a random domain suffix
func DomainSuffix() string { return domainSuffix(globalFaker.Rand) }
// DomainSuffix will generate a random domain suffix
func (f *Faker) DomainSuffix() string { return domainSuffix(f.Rand) }
func domainSuffix(r *rand.Rand) string {
return getRandValue(r, []string{"internet", "domain_suffix"})
}
// URL will generate a random url string
func URL() string { return url(globalFaker.Rand) }
// URL will generate a random url string
func (f *Faker) URL() string { return url(f.Rand) }
func url(r *rand.Rand) string {
// Slugs
num := number(r, 1, 4)
slug := make([]string, num)
for i := 0; i < num; i++ {
slug[i] = bs(r)
}
scheme := randomString(r, []string{"https", "http"})
path := strings.ToLower(strings.Join(slug, "/"))
url := fmt.Sprintf("%s://www.%s/%s", scheme, domainName(r), path)
url = strings.Replace(url, " ", "", -1)
return url
}
// HTTPMethod will generate a random http method
func HTTPMethod() string { return httpMethod(globalFaker.Rand) }
// HTTPMethod will generate a random http method
func (f *Faker) HTTPMethod() string { return httpMethod(f.Rand) }
func httpMethod(r *rand.Rand) string {
return getRandValue(r, []string{"internet", "http_method"})
}
// IPv4Address will generate a random version 4 ip address
func IPv4Address() string { return ipv4Address(globalFaker.Rand) }
// IPv4Address will generate a random version 4 ip address
func (f *Faker) IPv4Address() string { return ipv4Address(f.Rand) }
func ipv4Address(r *rand.Rand) string {
num := func() int { return r.Intn(256) }
return fmt.Sprintf("%d.%d.%d.%d", num(), num(), num(), num())
}
// IPv6Address will generate a random version 6 ip address
func IPv6Address() string { return ipv6Address(globalFaker.Rand) }
// IPv6Address will generate a random version 6 ip address
func (f *Faker) IPv6Address() string { return ipv6Address(f.Rand) }
func ipv6Address(r *rand.Rand) string {
num := func() int { return r.Intn(65536) }
return fmt.Sprintf("%x:%x:%x:%x:%x:%x:%x:%x", num(), num(), num(), num(), num(), num(), num(), num())
}
// MacAddress will generate a random mac address
func MacAddress() string { return macAddress(globalFaker.Rand) }
// MacAddress will generate a random mac address
func (f *Faker) MacAddress() string { return macAddress(f.Rand) }
func macAddress(r *rand.Rand) string {
num := 255
return fmt.Sprintf("%02x:%02x:%02x:%02x:%02x:%02x", r.Intn(num), r.Intn(num), r.Intn(num), r.Intn(num), r.Intn(num), r.Intn(num))
}
// HTTPStatusCode will generate a random status code
func HTTPStatusCode() int { return httpStatusCode(globalFaker.Rand) }
// HTTPStatusCode will generate a random status code
func (f *Faker) HTTPStatusCode() int { return httpStatusCode(f.Rand) }
func httpStatusCode(r *rand.Rand) int {
randInt, _ := strconv.Atoi(getRandValue(r, []string{"internet", "http_status_general"}))
return randInt
}
// HTTPStatusCodeSimple will generate a random simple status code
func HTTPStatusCodeSimple() int { return httpStatusCodeSimple(globalFaker.Rand) }
// HTTPStatusCodeSimple will generate a random simple status code
func (f *Faker) HTTPStatusCodeSimple() int { return httpStatusCodeSimple(f.Rand) }
func httpStatusCodeSimple(r *rand.Rand) int {
randInt, _ := strconv.Atoi(getRandValue(r, []string{"internet", "http_status_simple"}))
return randInt
}
// LogLevel will generate a random log level
// See data/LogLevels for list of available levels
func LogLevel(logType string) string { return logLevel(globalFaker.Rand, logType) }
// LogLevel will generate a random log level
// See data/LogLevels for list of available levels
func (f *Faker) LogLevel(logType string) string { return logLevel(f.Rand, logType) }
func logLevel(r *rand.Rand, logType string) string {
if _, ok := data.LogLevels[logType]; ok {
return getRandValue(r, []string{"log_level", logType})
}
return getRandValue(r, []string{"log_level", "general"})
}
// UserAgent will generate a random broswer user agent
func UserAgent() string { return userAgent(globalFaker.Rand) }
// UserAgent will generate a random broswer user agent
func (f *Faker) UserAgent() string { return userAgent(f.Rand) }
func userAgent(r *rand.Rand) string {
randNum := randIntRange(r, 0, 4)
switch randNum {
case 0:
return chromeUserAgent(r)
case 1:
return firefoxUserAgent(r)
case 2:
return safariUserAgent(r)
case 3:
return operaUserAgent(r)
default:
return chromeUserAgent(r)
}
}
// ChromeUserAgent will generate a random chrome browser user agent string
func ChromeUserAgent() string { return chromeUserAgent(globalFaker.Rand) }
// ChromeUserAgent will generate a random chrome browser user agent string
func (f *Faker) ChromeUserAgent() string { return chromeUserAgent(f.Rand) }
func chromeUserAgent(r *rand.Rand) string {
randNum1 := strconv.Itoa(randIntRange(r, 531, 536)) + strconv.Itoa(randIntRange(r, 0, 2))
randNum2 := strconv.Itoa(randIntRange(r, 36, 40))
randNum3 := strconv.Itoa(randIntRange(r, 800, 899))
return "Mozilla/5.0 " + "(" + randomPlatform(r) + ") AppleWebKit/" + randNum1 + " (KHTML, like Gecko) Chrome/" + randNum2 + ".0." + randNum3 + ".0 Mobile Safari/" + randNum1
}
// FirefoxUserAgent will generate a random firefox broswer user agent string
func FirefoxUserAgent() string { return firefoxUserAgent(globalFaker.Rand) }
// FirefoxUserAgent will generate a random firefox broswer user agent string
func (f *Faker) FirefoxUserAgent() string { return firefoxUserAgent(f.Rand) }
func firefoxUserAgent(r *rand.Rand) string {
ver := "Gecko/" + date(r).Format("2006-01-02") + " Firefox/" + strconv.Itoa(randIntRange(r, 35, 37)) + ".0"
platforms := []string{
"(" + windowsPlatformToken(r) + "; " + "en-US" + "; rv:1.9." + strconv.Itoa(randIntRange(r, 0, 3)) + ".20) " + ver,
"(" + linuxPlatformToken(r) + "; rv:" + strconv.Itoa(randIntRange(r, 5, 8)) + ".0) " + ver,
"(" + macPlatformToken(r) + " rv:" + strconv.Itoa(randIntRange(r, 2, 7)) + ".0) " + ver,
}
return "Mozilla/5.0 " + randomString(r, platforms)
}
// SafariUserAgent will generate a random safari browser user agent string
func SafariUserAgent() string { return safariUserAgent(globalFaker.Rand) }
// SafariUserAgent will generate a random safari browser user agent string
func (f *Faker) SafariUserAgent() string { return safariUserAgent(f.Rand) }
func safariUserAgent(r *rand.Rand) string {
randNum := strconv.Itoa(randIntRange(r, 531, 536)) + "." + strconv.Itoa(randIntRange(r, 1, 51)) + "." + strconv.Itoa(randIntRange(r, 1, 8))
ver := strconv.Itoa(randIntRange(r, 4, 6)) + "." + strconv.Itoa(randIntRange(r, 0, 2))
mobileDevices := []string{
"iPhone; CPU iPhone OS",
"iPad; CPU OS",
}
platforms := []string{
"(Windows; U; " + windowsPlatformToken(r) + ") AppleWebKit/" + randNum + " (KHTML, like Gecko) Version/" + ver + " Safari/" + randNum,
"(" + macPlatformToken(r) + " rv:" + strconv.Itoa(randIntRange(r, 4, 7)) + ".0; en-US) AppleWebKit/" + randNum + " (KHTML, like Gecko) Version/" + ver + " Safari/" + randNum,
"(" + randomString(r, mobileDevices) + " " + strconv.Itoa(randIntRange(r, 7, 9)) + "_" + strconv.Itoa(randIntRange(r, 0, 3)) + "_" + strconv.Itoa(randIntRange(r, 1, 3)) + " like Mac OS X; " + "en-US" + ") AppleWebKit/" + randNum + " (KHTML, like Gecko) Version/" + strconv.Itoa(randIntRange(r, 3, 5)) + ".0.5 Mobile/8B" + strconv.Itoa(randIntRange(r, 111, 120)) + " Safari/6" + randNum,
}
return "Mozilla/5.0 " + randomString(r, platforms)
}
// OperaUserAgent will generate a random opera browser user agent string
func OperaUserAgent() string { return operaUserAgent(globalFaker.Rand) }
// OperaUserAgent will generate a random opera browser user agent string
func (f *Faker) OperaUserAgent() string { return operaUserAgent(f.Rand) }
func operaUserAgent(r *rand.Rand) string {
platform := "(" + randomPlatform(r) + "; en-US) Presto/2." + strconv.Itoa(randIntRange(r, 8, 13)) + "." + strconv.Itoa(randIntRange(r, 160, 355)) + " Version/" + strconv.Itoa(randIntRange(r, 10, 13)) + ".00"
return "Opera/" + strconv.Itoa(randIntRange(r, 8, 10)) + "." + strconv.Itoa(randIntRange(r, 10, 99)) + " " + platform
}
// linuxPlatformToken will generate a random linux platform
func linuxPlatformToken(r *rand.Rand) string {
return "X11; Linux " + getRandValue(r, []string{"computer", "linux_processor"})
}
// macPlatformToken will generate a random mac platform
func macPlatformToken(r *rand.Rand) string {
return "Macintosh; " + getRandValue(r, []string{"computer", "mac_processor"}) + " Mac OS X 10_" + strconv.Itoa(randIntRange(r, 5, 9)) + "_" + strconv.Itoa(randIntRange(r, 0, 10))
}
// windowsPlatformToken will generate a random windows platform
func windowsPlatformToken(r *rand.Rand) string {
return getRandValue(r, []string{"computer", "windows_platform"})
}
// randomPlatform will generate a random platform
func randomPlatform(r *rand.Rand) string {
platforms := []string{
linuxPlatformToken(r),
macPlatformToken(r),
windowsPlatformToken(r),
}
return randomString(r, platforms)
}
// HTTPVersion will generate a random http version
func HTTPVersion() string { return httpVersion(globalFaker.Rand) }
// HTTPVersion will generate a random http version
func (f *Faker) HTTPVersion() string { return httpVersion(f.Rand) }
func httpVersion(r *rand.Rand) string {
return getRandValue(r, []string{"internet", "http_version"})
}
func addInternetLookup() {
AddFuncLookup("url", Info{
Display: "URL",
Category: "internet",
Description: "Web address that specifies the location of a resource on the internet",
Example: "http://www.principalproductize.biz/target",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return url(r), nil
},
})
AddFuncLookup("domainname", Info{
Display: "Domain Name",
Category: "internet",
Description: "Human-readable web address used to identify websites on the internet",
Example: "centraltarget.biz",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return domainName(r), nil
},
})
AddFuncLookup("domainsuffix", Info{
Display: "Domain Suffix",
Category: "internet",
Description: "The part of a domain name that comes after the last dot, indicating its type or purpose",
Example: "org",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return domainSuffix(r), nil
},
})
AddFuncLookup("ipv4address", Info{
Display: "IPv4 Address",
Category: "internet",
Description: "Numerical label assigned to devices on a network for identification and communication",
Example: "222.83.191.222",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return ipv4Address(r), nil
},
})
AddFuncLookup("ipv6address", Info{
Display: "IPv6 Address",
Category: "internet",
Description: "Numerical label assigned to devices on a network, providing a larger address space than IPv4 for internet communication",
Example: "2001:cafe:8898:ee17:bc35:9064:5866:d019",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return ipv6Address(r), nil
},
})
AddFuncLookup("httpmethod", Info{
Display: "HTTP Method",
Category: "internet",
Description: "Verb used in HTTP requests to specify the desired action to be performed on a resource",
Example: "HEAD",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return httpMethod(r), nil
},
})
AddFuncLookup("loglevel", Info{
Display: "Log Level",
Category: "internet",
Description: "Classification used in logging to indicate the severity or priority of a log entry",
Example: "error",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return logLevel(r, ""), nil
},
})
AddFuncLookup("useragent", Info{
Display: "User Agent",
Category: "internet",
Description: "String sent by a web browser to identify itself when requesting web content",
Example: "Mozilla/5.0 (Windows NT 5.0) AppleWebKit/5362 (KHTML, like Gecko) Chrome/37.0.834.0 Mobile Safari/5362",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return userAgent(r), nil
},
})
AddFuncLookup("chromeuseragent", Info{
Display: "Chrome User Agent",
Category: "internet",
Description: "The specific identification string sent by the Google Chrome web browser when making requests on the internet",
Example: "Mozilla/5.0 (X11; Linux i686) AppleWebKit/5312 (KHTML, like Gecko) Chrome/39.0.836.0 Mobile Safari/5312",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return chromeUserAgent(r), nil
},
})
AddFuncLookup("firefoxuseragent", Info{
Display: "Firefox User Agent",
Category: "internet",
Description: "The specific identification string sent by the Firefox web browser when making requests on the internet",
Example: "Mozilla/5.0 (Macintosh; U; PPC Mac OS X 10_8_3 rv:7.0) Gecko/1900-07-01 Firefox/37.0",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return firefoxUserAgent(r), nil
},
})
AddFuncLookup("operauseragent", Info{
Display: "Opera User Agent",
Category: "internet",
Description: "The specific identification string sent by the Opera web browser when making requests on the internet",
Example: "Opera/8.39 (Macintosh; U; PPC Mac OS X 10_8_7; en-US) Presto/2.9.335 Version/10.00",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return operaUserAgent(r), nil
},
})
AddFuncLookup("safariuseragent", Info{
Display: "Safari User Agent",
Category: "internet",
Description: "The specific identification string sent by the Safari web browser when making requests on the internet",
Example: "Mozilla/5.0 (iPad; CPU OS 8_3_2 like Mac OS X; en-US) AppleWebKit/531.15.6 (KHTML, like Gecko) Version/4.0.5 Mobile/8B120 Safari/6531.15.6",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return safariUserAgent(r), nil
},
})
AddFuncLookup("httpstatuscode", Info{
Display: "HTTP Status Code",
Category: "internet",
Description: "Random http status code",
Example: "200",
Output: "int",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return httpStatusCode(r), nil
},
})
AddFuncLookup("httpstatuscodesimple", Info{
Display: "HTTP Status Code Simple",
Category: "internet",
Description: "Three-digit number returned by a web server to indicate the outcome of an HTTP request",
Example: "404",
Output: "int",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return httpStatusCodeSimple(r), nil
},
})
AddFuncLookup("httpversion", Info{
Display: "HTTP Version",
Category: "internet",
Description: "Number indicating the version of the HTTP protocol used for communication between a client and a server",
Example: "HTTP/1.1",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return httpVersion(r), nil
},
})
AddFuncLookup("macaddress", Info{
Display: "MAC Address",
Category: "internet",
Description: "Unique identifier assigned to network interfaces, often used in Ethernet networks",
Example: "cb:ce:06:94:22:e9",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return macAddress(r), nil
},
})
}

335
vendor/github.com/brianvoe/gofakeit/v6/json.go generated vendored Normal file
View File

@ -0,0 +1,335 @@
package gofakeit
import (
"bytes"
"encoding/json"
"errors"
"fmt"
"math/rand"
"reflect"
"strconv"
)
// JSONOptions defines values needed for json generation
type JSONOptions struct {
Type string `json:"type" xml:"type" fake:"{randomstring:[array,object]}"` // array or object
RowCount int `json:"row_count" xml:"row_count" fake:"{number:1,10}"`
Indent bool `json:"indent" xml:"indent"`
Fields []Field `json:"fields" xml:"fields" fake:"{fields}"`
}
type jsonKeyVal struct {
Key string
Value any
}
type jsonOrderedKeyVal []*jsonKeyVal
func (okv jsonOrderedKeyVal) MarshalJSON() ([]byte, error) {
var buf bytes.Buffer
buf.WriteString("{")
for i, kv := range okv {
// Add comma to all except last one
if i != 0 {
buf.WriteString(",")
}
// Marshal key and write
key, err := json.Marshal(kv.Key)
if err != nil {
return nil, err
}
buf.Write(key)
// Write colon separator
buf.WriteString(":")
// Marshal value and write
val, err := json.Marshal(kv.Value)
if err != nil {
return nil, err
}
buf.Write(val)
}
buf.WriteString("}")
return buf.Bytes(), nil
}
// JSON generates an object or an array of objects in json format.
// A nil JSONOptions returns a randomly structured JSON.
func JSON(jo *JSONOptions) ([]byte, error) { return jsonFunc(globalFaker, jo) }
// JSON generates an object or an array of objects in json format.
// A nil JSONOptions returns a randomly structured JSON.
func (f *Faker) JSON(jo *JSONOptions) ([]byte, error) { return jsonFunc(f, jo) }
// JSON generates an object or an array of objects in json format
func jsonFunc(f *Faker, jo *JSONOptions) ([]byte, error) {
if jo == nil {
// We didn't get a JSONOptions, so create a new random one
err := f.Struct(&jo)
if err != nil {
return nil, err
}
}
// Check to make sure they passed in a type
if jo.Type != "array" && jo.Type != "object" {
return nil, errors.New("invalid type, must be array or object")
}
if jo.Fields == nil || len(jo.Fields) <= 0 {
return nil, errors.New("must pass fields in order to build json object(s)")
}
if jo.Type == "object" {
v := make(jsonOrderedKeyVal, len(jo.Fields))
// Loop through fields and add to them to map[string]any
for i, field := range jo.Fields {
if field.Function == "autoincrement" {
// Object only has one
v[i] = &jsonKeyVal{Key: field.Name, Value: 1}
continue
}
// Get function info
funcInfo := GetFuncLookup(field.Function)
if funcInfo == nil {
return nil, errors.New("invalid function, " + field.Function + " does not exist")
}
// Call function value
value, err := funcInfo.Generate(f.Rand, &field.Params, funcInfo)
if err != nil {
return nil, err
}
if _, ok := value.([]byte); ok {
// If it's a slice, unmarshal it into an interface
var val any
err := json.Unmarshal(value.([]byte), &val)
if err != nil {
return nil, err
}
value = val
}
v[i] = &jsonKeyVal{Key: field.Name, Value: value}
}
// Marshal into bytes
if jo.Indent {
j, _ := json.MarshalIndent(v, "", " ")
return j, nil
}
j, _ := json.Marshal(v)
return j, nil
}
if jo.Type == "array" {
// Make sure you set a row count
if jo.RowCount <= 0 {
return nil, errors.New("must have row count")
}
v := make([]jsonOrderedKeyVal, jo.RowCount)
for i := 0; i < int(jo.RowCount); i++ {
vr := make(jsonOrderedKeyVal, len(jo.Fields))
// Loop through fields and add to them to map[string]any
for ii, field := range jo.Fields {
if field.Function == "autoincrement" {
vr[ii] = &jsonKeyVal{Key: field.Name, Value: i + 1} // +1 because index starts with 0
continue
}
// Get function info
funcInfo := GetFuncLookup(field.Function)
if funcInfo == nil {
return nil, errors.New("invalid function, " + field.Function + " does not exist")
}
// Call function value
value, err := funcInfo.Generate(f.Rand, &field.Params, funcInfo)
if err != nil {
return nil, err
}
if _, ok := value.([]byte); ok {
// If it's a slice, unmarshal it into an interface
var val any
err := json.Unmarshal(value.([]byte), &val)
if err != nil {
return nil, err
}
value = val
}
vr[ii] = &jsonKeyVal{Key: field.Name, Value: value}
}
v[i] = vr
}
// Marshal into bytes
if jo.Indent {
j, _ := json.MarshalIndent(v, "", " ")
return j, nil
}
j, _ := json.Marshal(v)
return j, nil
}
return nil, errors.New("invalid type, must be array or object")
}
func addFileJSONLookup() {
AddFuncLookup("json", Info{
Display: "JSON",
Category: "file",
Description: "Format for structured data interchange used in programming, returns an object or an array of objects",
Example: `[
{ "first_name": "Markus", "last_name": "Moen", "password": "Dc0VYXjkWABx" },
{ "first_name": "Osborne", "last_name": "Hilll", "password": "XPJ9OVNbs5lm" },
{ "first_name": "Mertie", "last_name": "Halvorson", "password": "eyl3bhwfV8wA" }
]`,
Output: "[]byte",
ContentType: "application/json",
Params: []Param{
{Field: "type", Display: "Type", Type: "string", Default: "object", Options: []string{"object", "array"}, Description: "Type of JSON, object or array"},
{Field: "rowcount", Display: "Row Count", Type: "int", Default: "100", Description: "Number of rows in JSON array"},
{Field: "indent", Display: "Indent", Type: "bool", Default: "false", Description: "Whether or not to add indents and newlines"},
{Field: "fields", Display: "Fields", Type: "[]Field", Description: "Fields containing key name and function to run in json format"},
},
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
jo := JSONOptions{}
typ, err := info.GetString(m, "type")
if err != nil {
return nil, err
}
jo.Type = typ
rowcount, err := info.GetInt(m, "rowcount")
if err != nil {
return nil, err
}
jo.RowCount = rowcount
indent, err := info.GetBool(m, "indent")
if err != nil {
return nil, err
}
jo.Indent = indent
fieldsStr, err := info.GetStringArray(m, "fields")
if err != nil {
return nil, err
}
// Check to make sure fields has length
if len(fieldsStr) > 0 {
jo.Fields = make([]Field, len(fieldsStr))
for i, f := range fieldsStr {
// Unmarshal fields string into fields array
err = json.Unmarshal([]byte(f), &jo.Fields[i])
if err != nil {
return nil, err
}
}
}
f := &Faker{Rand: r}
return jsonFunc(f, &jo)
},
})
}
// encoding/json.RawMessage is a special case of []byte
// it cannot be handled as a reflect.Array/reflect.Slice
// because it needs additional structure in the output
func rJsonRawMessage(f *Faker, t reflect.Type, v reflect.Value, tag string, size int) error {
b, err := f.JSON(nil)
if err != nil {
return err
}
v.SetBytes(b)
return nil
}
// encoding/json.Number is a special case of string
// that represents a JSON number literal.
// It cannot be handled as a string because it needs to
// represent an integer or a floating-point number.
func rJsonNumber(f *Faker, t reflect.Type, v reflect.Value, tag string, size int) error {
var ret json.Number
var numberType string
if tag == "" {
numberType = f.RandomString([]string{"int", "float"})
switch numberType {
case "int":
retInt := f.Int16()
ret = json.Number(strconv.Itoa(int(retInt)))
case "float":
retFloat := f.Float64()
ret = json.Number(strconv.FormatFloat(retFloat, 'f', -1, 64))
}
} else {
fName, fParams := parseNameAndParamsFromTag(tag)
info := GetFuncLookup(fName)
if info == nil {
return fmt.Errorf("invalid function, %s does not exist", fName)
}
// Parse map params
mapParams := parseMapParams(info, fParams)
valueIface, err := info.Generate(f.Rand, mapParams, info)
if err != nil {
return err
}
switch value := valueIface.(type) {
case int:
ret = json.Number(strconv.FormatInt(int64(value), 10))
case int8:
ret = json.Number(strconv.FormatInt(int64(value), 10))
case int16:
ret = json.Number(strconv.FormatInt(int64(value), 10))
case int32:
ret = json.Number(strconv.FormatInt(int64(value), 10))
case int64:
ret = json.Number(strconv.FormatInt(int64(value), 10))
case uint:
ret = json.Number(strconv.FormatUint(uint64(value), 10))
case uint8:
ret = json.Number(strconv.FormatUint(uint64(value), 10))
case uint16:
ret = json.Number(strconv.FormatUint(uint64(value), 10))
case uint32:
ret = json.Number(strconv.FormatUint(uint64(value), 10))
case uint64:
ret = json.Number(strconv.FormatUint(uint64(value), 10))
case float32:
ret = json.Number(strconv.FormatFloat(float64(value), 'f', -1, 64))
case float64:
ret = json.Number(strconv.FormatFloat(float64(value), 'f', -1, 64))
default:
return fmt.Errorf("invalid type, %s is not a valid type for json.Number", reflect.TypeOf(value))
}
}
v.Set(reflect.ValueOf(ret))
return nil
}

91
vendor/github.com/brianvoe/gofakeit/v6/languages.go generated vendored Normal file
View File

@ -0,0 +1,91 @@
package gofakeit
import "math/rand"
// Language will return a random language
func Language() string { return language(globalFaker.Rand) }
// Language will return a random language
func (f *Faker) Language() string { return language(f.Rand) }
func language(r *rand.Rand) string { return getRandValue(r, []string{"language", "long"}) }
// LanguageAbbreviation will return a random language abbreviation
func LanguageAbbreviation() string { return languageAbbreviation(globalFaker.Rand) }
// LanguageAbbreviation will return a random language abbreviation
func (f *Faker) LanguageAbbreviation() string { return languageAbbreviation(f.Rand) }
func languageAbbreviation(r *rand.Rand) string { return getRandValue(r, []string{"language", "short"}) }
// LanguageBCP will return a random language BCP (Best Current Practices)
func LanguageBCP() string { return languageBCP(globalFaker.Rand) }
// LanguageBCP will return a random language BCP (Best Current Practices)
func (f *Faker) LanguageBCP() string { return languageBCP(f.Rand) }
func languageBCP(r *rand.Rand) string { return getRandValue(r, []string{"language", "bcp"}) }
// ProgrammingLanguage will return a random programming language
func ProgrammingLanguage() string { return programmingLanguage(globalFaker.Rand) }
// ProgrammingLanguage will return a random programming language
func (f *Faker) ProgrammingLanguage() string { return programmingLanguage(f.Rand) }
func programmingLanguage(r *rand.Rand) string {
return getRandValue(r, []string{"language", "programming"})
}
// ProgrammingLanguageBest will return a random programming language
func ProgrammingLanguageBest() string { return programmingLanguageBest(globalFaker.Rand) }
// ProgrammingLanguageBest will return a random programming language
func (f *Faker) ProgrammingLanguageBest() string { return programmingLanguageBest(f.Rand) }
func programmingLanguageBest(r *rand.Rand) string { return "Go" }
func addLanguagesLookup() {
AddFuncLookup("language", Info{
Display: "Language",
Category: "language",
Description: "System of communication using symbols, words, and grammar to convey meaning between individuals",
Example: "Kazakh",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return language(r), nil
},
})
AddFuncLookup("languageabbreviation", Info{
Display: "Language Abbreviation",
Category: "language",
Description: "Shortened form of a language's name",
Example: "kk",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return languageAbbreviation(r), nil
},
})
AddFuncLookup("languagebcp", Info{
Display: "Language BCP",
Category: "language",
Description: "Set of guidelines and standards for identifying and representing languages in computing and internet protocols",
Example: "en-US",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return languageBCP(r), nil
},
})
AddFuncLookup("programminglanguage", Info{
Display: "Programming Language",
Category: "language",
Description: "Formal system of instructions used to create software and perform computational tasks",
Example: "Go",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return programmingLanguage(r), nil
},
})
}

BIN
vendor/github.com/brianvoe/gofakeit/v6/logo.png generated vendored Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 26 KiB

511
vendor/github.com/brianvoe/gofakeit/v6/lookup.go generated vendored Normal file
View File

@ -0,0 +1,511 @@
package gofakeit
import (
"encoding/json"
"fmt"
"math/rand"
"reflect"
"strconv"
"strings"
"sync"
)
// FuncLookups is the primary map array with mapping to all available data
var FuncLookups map[string]Info
var lockFuncLookups sync.Mutex
// MapParams is the values to pass into a lookup generate
type MapParams map[string]MapParamsValue
type MapParamsValue []string
// Info structures fields to better break down what each one generates
type Info struct {
Display string `json:"display"`
Category string `json:"category"`
Description string `json:"description"`
Example string `json:"example"`
Output string `json:"output"`
ContentType string `json:"content_type"`
Params []Param `json:"params"`
Any any `json:"any"`
Generate func(r *rand.Rand, m *MapParams, info *Info) (any, error) `json:"-"`
}
// Param is a breakdown of param requirements and type definition
type Param struct {
Field string `json:"field"`
Display string `json:"display"`
Type string `json:"type"`
Optional bool `json:"optional"`
Default string `json:"default"`
Options []string `json:"options"`
Description string `json:"description"`
}
// Field is used for defining what name and function you to generate for file outuputs
type Field struct {
Name string `json:"name"`
Function string `json:"function"`
Params MapParams `json:"params"`
}
func init() { initLookup() }
// init will add all the functions to MapLookups
func initLookup() {
addAddressLookup()
addAnimalLookup()
addAppLookup()
addAuthLookup()
addBeerLookup()
addBookLookup()
addCarLookup()
addCelebrityLookup()
addColorLookup()
addCompanyLookup()
addDatabaseSQLLookup()
addDateTimeLookup()
addEmojiLookup()
addErrorLookup()
addFileCSVLookup()
addFileJSONLookup()
addFileLookup()
addFileXMLLookup()
addFinanceLookup()
addFoodLookup()
addGameLookup()
addGenerateLookup()
addHackerLookup()
addHipsterLookup()
addHtmlLookup()
addImageLookup()
addInternetLookup()
addLanguagesLookup()
addLoremLookup()
addMinecraftLookup()
addMiscLookup()
addMovieLookup()
addNumberLookup()
addPaymentLookup()
addPersonLookup()
addProductLookup()
addSchoolLookup()
addStringLookup()
addTemplateLookup()
addWeightedLookup()
addWordAdjectiveLookup()
addWordAdverbLookup()
addWordConnectiveLookup()
addWordGeneralLookup()
addWordGrammerLookup()
addWordNounLookup()
addWordPhraseLookup()
addWordPrepositionLookup()
addWordPronounLookup()
addWordSentenceLookup()
addWordVerbLookup()
addWordCommentLookup()
addWordMiscLookup()
}
// internalFuncLookups is the internal map array with mapping to all available data
var internalFuncLookups map[string]Info = map[string]Info{
"fields": {
Description: "Example fields for generating csv, json, xml, etc",
Output: "gofakeit.Field",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
function, _ := GetRandomSimpleFunc(r)
return Field{
Name: function,
Function: function,
}, nil
},
},
}
// NewMapParams will create a new MapParams
func NewMapParams() *MapParams {
return &MapParams{}
}
// Add will take in a field and value and add it to the map params type
func (m *MapParams) Add(field string, value string) {
_, ok := (*m)[field]
if !ok {
(*m)[field] = []string{value}
return
}
(*m)[field] = append((*m)[field], value)
}
// Get will return the array of string from the provided field
func (m *MapParams) Get(field string) []string {
return (*m)[field]
}
// Size will return the total size of the underlying map
func (m *MapParams) Size() int {
size := 0
for range *m {
size++
}
return size
}
// UnmarshalJSON will unmarshal the json into the []string
func (m *MapParamsValue) UnmarshalJSON(data []byte) error {
// check if the data is an array
// if so, marshal it into m
if data[0] == '[' {
var values []any
err := json.Unmarshal(data, &values)
if err != nil {
return err
}
// convert the values to array of strings
for _, value := range values {
typeOf := reflect.TypeOf(value).Kind().String()
if typeOf == "map" {
v, err := json.Marshal(value)
if err != nil {
return err
}
*m = append(*m, string(v))
} else {
*m = append(*m, fmt.Sprintf("%v", value))
}
}
return nil
}
// if not, then convert into a string and add it to m
var s any
if err := json.Unmarshal(data, &s); err != nil {
return err
}
*m = append(*m, fmt.Sprintf("%v", s))
return nil
}
func GetRandomSimpleFunc(r *rand.Rand) (string, Info) {
// Loop through all the functions and add them to a slice
var keys []string
for k, info := range FuncLookups {
// Only grab simple functions
if info.Params == nil {
keys = append(keys, k)
}
}
// Randomly grab a function from the slice
randomKey := randomString(r, keys)
// Return the function name and info
return randomKey, FuncLookups[randomKey]
}
// AddFuncLookup takes a field and adds it to map
func AddFuncLookup(functionName string, info Info) {
if FuncLookups == nil {
FuncLookups = make(map[string]Info)
}
// Check content type
if info.ContentType == "" {
info.ContentType = "text/plain"
}
lockFuncLookups.Lock()
FuncLookups[functionName] = info
lockFuncLookups.Unlock()
}
// GetFuncLookup will lookup
func GetFuncLookup(functionName string) *Info {
var info Info
var ok bool
// Check internal functions first
info, ok = internalFuncLookups[functionName]
if ok {
return &info
}
info, ok = FuncLookups[functionName]
if ok {
return &info
}
return nil
}
// RemoveFuncLookup will remove a function from lookup
func RemoveFuncLookup(functionName string) {
_, ok := FuncLookups[functionName]
if !ok {
return
}
lockFuncLookups.Lock()
delete(FuncLookups, functionName)
lockFuncLookups.Unlock()
}
// GetAny will retrieve Any field from Info
func (i *Info) GetAny(m *MapParams, field string) (any, error) {
_, value, err := i.GetField(m, field)
if err != nil {
return nil, err
}
var anyValue any
// Try to convert to int
valueInt, err := strconv.ParseInt(value[0], 10, 64)
if err == nil {
return int(valueInt), nil
}
// Try to convert to float
valueFloat, err := strconv.ParseFloat(value[0], 64)
if err == nil {
return valueFloat, nil
}
// Try to convert to boolean
valueBool, err := strconv.ParseBool(value[0])
if err == nil {
return valueBool, nil
}
err = json.Unmarshal([]byte(value[0]), &anyValue)
if err == nil {
return valueBool, nil
}
return value[0], nil
}
// GetMap will retrieve map[string]any field from data
func (i *Info) GetMap(m *MapParams, field string) (map[string]any, error) {
_, value, err := i.GetField(m, field)
if err != nil {
return nil, err
}
var mapValue map[string]any
err = json.Unmarshal([]byte(value[0]), &mapValue)
if err != nil {
return nil, fmt.Errorf("%s field could not parse to map[string]any", field)
}
return mapValue, nil
}
// GetField will retrieve field from data
func (i *Info) GetField(m *MapParams, field string) (*Param, []string, error) {
// Get param
var p *Param
for _, param := range i.Params {
if param.Field == field {
p = &param
break
}
}
if p == nil {
return nil, nil, fmt.Errorf("could not find param field %s", field)
}
// Get value from map
if m != nil {
value, ok := (*m)[field]
if !ok {
// If default isnt empty use default
if p.Default != "" {
return p, []string{p.Default}, nil
}
return nil, nil, fmt.Errorf("could not find field: %s", field)
}
return p, value, nil
} else if m == nil && p.Default != "" {
// If p.Type is []uint, then we need to convert it to []string
if strings.HasPrefix(p.Default, "[") {
// Remove [] from type
defaultClean := p.Default[1 : len(p.Default)-1]
// Split on comma
defaultSplit := strings.Split(defaultClean, ",")
return p, defaultSplit, nil
}
// If default isnt empty use default
return p, []string{p.Default}, nil
}
return nil, nil, fmt.Errorf("could not find field: %s", field)
}
// GetBool will retrieve boolean field from data
func (i *Info) GetBool(m *MapParams, field string) (bool, error) {
p, value, err := i.GetField(m, field)
if err != nil {
return false, err
}
// Try to convert to boolean
valueBool, err := strconv.ParseBool(value[0])
if err != nil {
return false, fmt.Errorf("%s field could not parse to bool value", p.Field)
}
return valueBool, nil
}
// GetInt will retrieve int field from data
func (i *Info) GetInt(m *MapParams, field string) (int, error) {
p, value, err := i.GetField(m, field)
if err != nil {
return 0, err
}
// Try to convert to int
valueInt, err := strconv.ParseInt(value[0], 10, 64)
if err != nil {
return 0, fmt.Errorf("%s field could not parse to int value", p.Field)
}
return int(valueInt), nil
}
// GetUint will retrieve uint field from data
func (i *Info) GetUint(m *MapParams, field string) (uint, error) {
p, value, err := i.GetField(m, field)
if err != nil {
return 0, err
}
// Try to convert to int
valueUint, err := strconv.ParseUint(value[0], 10, 64)
if err != nil {
return 0, fmt.Errorf("%s field could not parse to int value", p.Field)
}
return uint(valueUint), nil
}
// GetFloat32 will retrieve int field from data
func (i *Info) GetFloat32(m *MapParams, field string) (float32, error) {
p, value, err := i.GetField(m, field)
if err != nil {
return 0, err
}
// Try to convert to float
valueFloat, err := strconv.ParseFloat(value[0], 32)
if err != nil {
return 0, fmt.Errorf("%s field could not parse to float value", p.Field)
}
return float32(valueFloat), nil
}
// GetFloat64 will retrieve int field from data
func (i *Info) GetFloat64(m *MapParams, field string) (float64, error) {
p, value, err := i.GetField(m, field)
if err != nil {
return 0, err
}
// Try to convert to float
valueFloat, err := strconv.ParseFloat(value[0], 64)
if err != nil {
return 0, fmt.Errorf("%s field could not parse to float value", p.Field)
}
return valueFloat, nil
}
// GetString will retrieve string field from data
func (i *Info) GetString(m *MapParams, field string) (string, error) {
_, value, err := i.GetField(m, field)
if err != nil {
return "", err
}
return value[0], nil
}
// GetStringArray will retrieve []string field from data
func (i *Info) GetStringArray(m *MapParams, field string) ([]string, error) {
_, values, err := i.GetField(m, field)
if err != nil {
return nil, err
}
return values, nil
}
// GetIntArray will retrieve []int field from data
func (i *Info) GetIntArray(m *MapParams, field string) ([]int, error) {
_, value, err := i.GetField(m, field)
if err != nil {
return nil, err
}
var ints []int
for i := 0; i < len(value); i++ {
valueInt, err := strconv.ParseInt(value[i], 10, 64)
if err != nil {
return nil, fmt.Errorf("%s value could not parse to int", value[i])
}
ints = append(ints, int(valueInt))
}
return ints, nil
}
// GetUintArray will retrieve []uint field from data
func (i *Info) GetUintArray(m *MapParams, field string) ([]uint, error) {
_, value, err := i.GetField(m, field)
if err != nil {
return nil, err
}
var uints []uint
for i := 0; i < len(value); i++ {
valueUint, err := strconv.ParseUint(value[i], 10, 64)
if err != nil {
return nil, fmt.Errorf("%s value could not parse to uint", value[i])
}
uints = append(uints, uint(valueUint))
}
return uints, nil
}
// GetFloat32Array will retrieve []float field from data
func (i *Info) GetFloat32Array(m *MapParams, field string) ([]float32, error) {
_, value, err := i.GetField(m, field)
if err != nil {
return nil, err
}
var floats []float32
for i := 0; i < len(value); i++ {
valueFloat, err := strconv.ParseFloat(value[i], 32)
if err != nil {
return nil, fmt.Errorf("%s value could not parse to float", value[i])
}
floats = append(floats, float32(valueFloat))
}
return floats, nil
}

127
vendor/github.com/brianvoe/gofakeit/v6/lorem.go generated vendored Normal file
View File

@ -0,0 +1,127 @@
package gofakeit
import (
"errors"
"math/rand"
)
// LoremIpsumWord will generate a random word
func LoremIpsumWord() string { return loremIpsumWord(globalFaker.Rand) }
// LoremIpsumWord will generate a random word
func (f *Faker) LoremIpsumWord() string { return loremIpsumWord(f.Rand) }
func loremIpsumWord(r *rand.Rand) string { return getRandValue(r, []string{"lorem", "word"}) }
// LoremIpsumSentence will generate a random sentence
func LoremIpsumSentence(wordCount int) string {
return loremIpsumSentence(globalFaker.Rand, wordCount)
}
// LoremIpsumSentence will generate a random sentence
func (f *Faker) LoremIpsumSentence(wordCount int) string {
return loremIpsumSentence(f.Rand, wordCount)
}
func loremIpsumSentence(r *rand.Rand, wordCount int) string {
return sentenceGen(r, wordCount, loremIpsumWord)
}
// LoremIpsumParagraph will generate a random paragraphGenerator
func LoremIpsumParagraph(paragraphCount int, sentenceCount int, wordCount int, separator string) string {
return loremIpsumParagraph(globalFaker.Rand, paragraphCount, sentenceCount, wordCount, separator)
}
// LoremIpsumParagraph will generate a random paragraphGenerator
func (f *Faker) LoremIpsumParagraph(paragraphCount int, sentenceCount int, wordCount int, separator string) string {
return loremIpsumParagraph(f.Rand, paragraphCount, sentenceCount, wordCount, separator)
}
func loremIpsumParagraph(r *rand.Rand, paragraphCount int, sentenceCount int, wordCount int, separator string) string {
return paragraphGen(r, paragrapOptions{paragraphCount, sentenceCount, wordCount, separator}, loremIpsumSentence)
}
func addLoremLookup() {
AddFuncLookup("loremipsumword", Info{
Display: "Lorem Ipsum Word",
Category: "word",
Description: "Word of the Lorem Ipsum placeholder text used in design and publishing",
Example: "quia",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return loremIpsumWord(r), nil
},
})
AddFuncLookup("loremipsumsentence", Info{
Display: "Lorem Ipsum Sentence",
Category: "word",
Description: "Sentence of the Lorem Ipsum placeholder text used in design and publishing",
Example: "Quia quae repellat consequatur quidem.",
Output: "string",
Params: []Param{
{Field: "wordcount", Display: "Word Count", Type: "int", Default: "5", Description: "Number of words in a sentence"},
},
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
wordCount, err := info.GetInt(m, "wordcount")
if err != nil {
return nil, err
}
if wordCount <= 0 || wordCount > 50 {
return nil, errors.New("invalid word count, must be greater than 0, less than 50")
}
return loremIpsumSentence(r, wordCount), nil
},
})
AddFuncLookup("loremipsumparagraph", Info{
Display: "Lorem Ipsum Paragraph",
Category: "word",
Description: "Paragraph of the Lorem Ipsum placeholder text used in design and publishing",
Example: `Quia quae repellat consequatur quidem nisi quo qui voluptatum accusantium quisquam amet. Quas et ut non dolorem ipsam aut enim assumenda mollitia harum ut. Dicta similique veniam nulla voluptas at excepturi non ad maxime at non. Eaque hic repellat praesentium voluptatem qui consequuntur dolor iusto autem velit aut. Fugit tempore exercitationem harum consequatur voluptatum modi minima aut eaque et et.
Aut ea voluptatem dignissimos expedita odit tempore quod aut beatae ipsam iste. Minus voluptatibus dolorem maiores eius sed nihil vel enim odio voluptatem accusamus. Natus quibusdam temporibus tenetur cumque sint necessitatibus dolorem ex ducimus iusto ex. Voluptatem neque dicta explicabo officiis et ducimus sit ut ut praesentium pariatur. Illum molestias nisi at dolore ut voluptatem accusantium et fugiat et ut.
Explicabo incidunt reprehenderit non quia dignissimos recusandae vitae soluta quia et quia. Aut veniam voluptas consequatur placeat sapiente non eveniet voluptatibus magni velit eum. Nobis vel repellendus sed est qui autem laudantium quidem quam ullam consequatur. Aut iusto ut commodi similique quae voluptatem atque qui fugiat eum aut. Quis distinctio consequatur voluptatem vel aliquid aut laborum facere officiis iure tempora.`,
Output: "string",
Params: []Param{
{Field: "paragraphcount", Display: "Paragraph Count", Type: "int", Default: "2", Description: "Number of paragraphs"},
{Field: "sentencecount", Display: "Sentence Count", Type: "int", Default: "2", Description: "Number of sentences in a paragraph"},
{Field: "wordcount", Display: "Word Count", Type: "int", Default: "5", Description: "Number of words in a sentence"},
{Field: "paragraphseparator", Display: "Paragraph Separator", Type: "string", Default: "<br />", Description: "String value to add between paragraphs"},
},
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
paragraphCount, err := info.GetInt(m, "paragraphcount")
if err != nil {
return nil, err
}
if paragraphCount <= 0 || paragraphCount > 20 {
return nil, errors.New("invalid paragraph count, must be greater than 0, less than 20")
}
sentenceCount, err := info.GetInt(m, "sentencecount")
if err != nil {
return nil, err
}
if sentenceCount <= 0 || sentenceCount > 20 {
return nil, errors.New("invalid sentence count, must be greater than 0, less than 20")
}
wordCount, err := info.GetInt(m, "wordcount")
if err != nil {
return nil, err
}
if wordCount <= 0 || wordCount > 50 {
return nil, errors.New("invalid word count, must be greater than 0, less than 50")
}
paragraphSeparator, err := info.GetString(m, "paragraphseparator")
if err != nil {
return nil, err
}
return loremIpsumParagraph(r, paragraphCount, sentenceCount, wordCount, paragraphSeparator), nil
},
})
}

367
vendor/github.com/brianvoe/gofakeit/v6/minecraft.go generated vendored Normal file
View File

@ -0,0 +1,367 @@
package gofakeit
import "math/rand"
// MinecraftOre will generate a random Minecraft ore
func MinecraftOre() string { return minecraftOre(globalFaker.Rand) }
// MinecraftOre will generate a random Minecraft ore
func (f *Faker) MinecraftOre() string { return minecraftOre(f.Rand) }
func minecraftOre(r *rand.Rand) string { return getRandValue(r, []string{"minecraft", "ore"}) }
// MinecraftWood will generate a random Minecraft wood
func MinecraftWood() string { return minecraftWood(globalFaker.Rand) }
// MinecraftWood will generate a random Minecraft wood
func (f *Faker) MinecraftWood() string { return minecraftWood(f.Rand) }
func minecraftWood(r *rand.Rand) string { return getRandValue(r, []string{"minecraft", "wood"}) }
// MinecraftArmorTier will generate a random Minecraft armor tier
func MinecraftArmorTier() string { return minecraftArmorTier(globalFaker.Rand) }
// MinecraftArmorTier will generate a random Minecraft armor tier
func (f *Faker) MinecraftArmorTier() string { return minecraftArmorTier(f.Rand) }
func minecraftArmorTier(r *rand.Rand) string {
return getRandValue(r, []string{"minecraft", "armortier"})
}
// MinecraftArmorPart will generate a random Minecraft armor part
func MinecraftArmorPart() string { return minecraftArmorPart(globalFaker.Rand) }
// MinecraftArmorPart will generate a random Minecraft armor part
func (f *Faker) MinecraftArmorPart() string { return minecraftArmorPart(f.Rand) }
func minecraftArmorPart(r *rand.Rand) string {
return getRandValue(r, []string{"minecraft", "armorpart"})
}
// MinecraftWeapon will generate a random Minecraft weapon
func MinecraftWeapon() string { return minecraftWeapon(globalFaker.Rand) }
// MinecraftWeapon will generate a random Minecraft weapon
func (f *Faker) MinecraftWeapon() string { return minecraftWeapon(f.Rand) }
func minecraftWeapon(r *rand.Rand) string { return getRandValue(r, []string{"minecraft", "weapon"}) }
// MinecraftTool will generate a random Minecraft tool
func MinecraftTool() string { return minecraftTool(globalFaker.Rand) }
// MinecraftTool will generate a random Minecraft tool
func (f *Faker) MinecraftTool() string { return minecraftTool(f.Rand) }
func minecraftTool(r *rand.Rand) string { return getRandValue(r, []string{"minecraft", "tool"}) }
// MinecraftDye will generate a random Minecraft dye
func MinecraftDye() string { return minecraftDye(globalFaker.Rand) }
// MinecraftDye will generate a random Minecraft dye
func (f *Faker) MinecraftDye() string { return minecraftDye(f.Rand) }
func minecraftDye(r *rand.Rand) string { return getRandValue(r, []string{"minecraft", "dye"}) }
// MinecraftFood will generate a random Minecraft food
func MinecraftFood() string { return minecraftFood(globalFaker.Rand) }
// MinecraftFood will generate a random Minecraft food
func (f *Faker) MinecraftFood() string { return minecraftFood(f.Rand) }
func minecraftFood(r *rand.Rand) string { return getRandValue(r, []string{"minecraft", "food"}) }
// MinecraftAnimal will generate a random Minecraft animal
func MinecraftAnimal() string { return minecraftAnimal(globalFaker.Rand) }
// MinecraftAnimal will generate a random Minecraft animal
func (f *Faker) MinecraftAnimal() string { return minecraftAnimal(f.Rand) }
func minecraftAnimal(r *rand.Rand) string {
return getRandValue(r, []string{"minecraft", "animal"})
}
// MinecraftVillagerJob will generate a random Minecraft villager job
func MinecraftVillagerJob() string { return minecraftVillagerJob(globalFaker.Rand) }
// MinecraftVillagerJob will generate a random Minecraft villager job
func (f *Faker) MinecraftVillagerJob() string { return minecraftVillagerJob(f.Rand) }
func minecraftVillagerJob(r *rand.Rand) string {
return getRandValue(r, []string{"minecraft", "villagerjob"})
}
// MinecraftVillagerStation will generate a random Minecraft villager station
func MinecraftVillagerStation() string { return minecraftVillagerStation(globalFaker.Rand) }
// MinecraftVillagerStation will generate a random Minecraft villager station
func (f *Faker) MinecraftVillagerStation() string { return minecraftVillagerStation(f.Rand) }
func minecraftVillagerStation(r *rand.Rand) string {
return getRandValue(r, []string{"minecraft", "villagerstation"})
}
// MinecraftVillagerLevel will generate a random Minecraft villager level
func MinecraftVillagerLevel() string { return minecraftVillagerLevel(globalFaker.Rand) }
// MinecraftVillagerLevel will generate a random Minecraft villager level
func (f *Faker) MinecraftVillagerLevel() string { return minecraftVillagerLevel(f.Rand) }
func minecraftVillagerLevel(r *rand.Rand) string {
return getRandValue(r, []string{"minecraft", "villagerlevel"})
}
// MinecraftMobPassive will generate a random Minecraft mob passive
func MinecraftMobPassive() string { return minecraftMobPassive(globalFaker.Rand) }
// MinecraftMobPassive will generate a random Minecraft mob passive
func (f *Faker) MinecraftMobPassive() string { return minecraftMobPassive(f.Rand) }
func minecraftMobPassive(r *rand.Rand) string {
return getRandValue(r, []string{"minecraft", "mobpassive"})
}
// MinecraftMobNeutral will generate a random Minecraft mob neutral
func MinecraftMobNeutral() string { return minecraftMobNeutral(globalFaker.Rand) }
// MinecraftMobNeutral will generate a random Minecraft mob neutral
func (f *Faker) MinecraftMobNeutral() string { return minecraftMobNeutral(f.Rand) }
func minecraftMobNeutral(r *rand.Rand) string {
return getRandValue(r, []string{"minecraft", "mobneutral"})
}
// MinecraftMobHostile will generate a random Minecraft mob hostile
func MinecraftMobHostile() string { return minecraftMobHostile(globalFaker.Rand) }
// MinecraftMobHostile will generate a random Minecraft mob hostile
func (f *Faker) MinecraftMobHostile() string { return minecraftMobHostile(f.Rand) }
func minecraftMobHostile(r *rand.Rand) string {
return getRandValue(r, []string{"minecraft", "mobhostile"})
}
// MinecraftMobBoss will generate a random Minecraft mob boss
func MinecraftMobBoss() string { return minecraftMobBoss(globalFaker.Rand) }
// MinecraftMobBoss will generate a random Minecraft mob boss
func (f *Faker) MinecraftMobBoss() string { return minecraftMobBoss(f.Rand) }
func minecraftMobBoss(r *rand.Rand) string {
return getRandValue(r, []string{"minecraft", "mobboss"})
}
// MinecraftBiome will generate a random Minecraft biome
func MinecraftBiome() string { return minecraftBiome(globalFaker.Rand) }
// MinecraftBiome will generate a random Minecraft biome
func (f *Faker) MinecraftBiome() string { return minecraftBiome(f.Rand) }
func minecraftBiome(r *rand.Rand) string { return getRandValue(r, []string{"minecraft", "biome"}) }
// MinecraftWeather will generate a random Minecraft weather
func MinecraftWeather() string { return minecraftWeather(globalFaker.Rand) }
// MinecraftWeather will generate a random Minecraft weather
func (f *Faker) MinecraftWeather() string { return minecraftWeather(f.Rand) }
func minecraftWeather(r *rand.Rand) string { return getRandValue(r, []string{"minecraft", "weather"}) }
func addMinecraftLookup() {
AddFuncLookup("minecraftore", Info{
Display: "Minecraft ore",
Category: "minecraft",
Description: "Naturally occurring minerals found in the game Minecraft, used for crafting purposes",
Example: "coal",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return minecraftOre(r), nil
},
})
AddFuncLookup("minecraftwood", Info{
Display: "Minecraft wood",
Category: "minecraft",
Description: "Natural resource in Minecraft, used for crafting various items and building structures",
Example: "oak",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return minecraftWood(r), nil
},
})
AddFuncLookup("minecraftarmortier", Info{
Display: "Minecraft armor tier",
Category: "minecraft",
Description: "Classification system for armor sets in Minecraft, indicating their effectiveness and protection level",
Example: "iron",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return minecraftArmorTier(r), nil
},
})
AddFuncLookup("minecraftarmorpart", Info{
Display: "Minecraft armor part",
Category: "minecraft",
Description: "Component of an armor set in Minecraft, such as a helmet, chestplate, leggings, or boots",
Example: "helmet",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return minecraftArmorPart(r), nil
},
})
AddFuncLookup("minecraftweapon", Info{
Display: "Minecraft weapon",
Category: "minecraft",
Description: "Tools and items used in Minecraft for combat and defeating hostile mobs",
Example: "bow",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return minecraftWeapon(r), nil
},
})
AddFuncLookup("minecrafttool", Info{
Display: "Minecraft tool",
Category: "minecraft",
Description: "Items in Minecraft designed for specific tasks, including mining, digging, and building",
Example: "shovel",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return minecraftTool(r), nil
},
})
AddFuncLookup("minecraftdye", Info{
Display: "Minecraft dye",
Category: "minecraft",
Description: "Items used to change the color of various in-game objects",
Example: "white",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return minecraftDye(r), nil
},
})
AddFuncLookup("minecraftfood", Info{
Display: "Minecraft food",
Category: "minecraft",
Description: "Consumable items in Minecraft that provide nourishment to the player character",
Example: "apple",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return minecraftFood(r), nil
},
})
AddFuncLookup("minecraftanimal", Info{
Display: "Minecraft animal",
Category: "minecraft",
Description: "Non-hostile creatures in Minecraft, often used for resources and farming",
Example: "chicken",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return minecraftAnimal(r), nil
},
})
AddFuncLookup("minecraftvillagerjob", Info{
Display: "Minecraft villager job",
Category: "minecraft",
Description: "The profession or occupation assigned to a villager character in the game",
Example: "farmer",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return minecraftVillagerJob(r), nil
},
})
AddFuncLookup("minecraftvillagerstation", Info{
Display: "Minecraft villager station",
Category: "minecraft",
Description: "Designated area or structure in Minecraft where villagers perform their job-related tasks and trading",
Example: "furnace",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return minecraftVillagerStation(r), nil
},
})
AddFuncLookup("minecraftvillagerlevel", Info{
Display: "Minecraft villager level",
Category: "minecraft",
Description: "Measure of a villager's experience and proficiency in their assigned job or profession",
Example: "master",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return minecraftVillagerLevel(r), nil
},
})
AddFuncLookup("minecraftmobpassive", Info{
Display: "Minecraft mob passive",
Category: "minecraft",
Description: "Non-aggressive creatures in the game that do not attack players",
Example: "cow",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return minecraftMobPassive(r), nil
},
})
AddFuncLookup("minecraftmobneutral", Info{
Display: "Minecraft mob neutral",
Category: "minecraft",
Description: "Creature in the game that only becomes hostile if provoked, typically defending itself when attacked",
Example: "bee",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return minecraftMobNeutral(r), nil
},
})
AddFuncLookup("minecraftmobhostile", Info{
Display: "Minecraft mob hostile",
Category: "minecraft",
Description: "Aggressive creatures in the game that actively attack players when encountered",
Example: "spider",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return minecraftMobHostile(r), nil
},
})
AddFuncLookup("minecraftmobboss", Info{
Display: "Minecraft mob boss",
Category: "minecraft",
Description: "Powerful hostile creature in the game, often found in challenging dungeons or structures",
Example: "ender dragon",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return minecraftMobBoss(r), nil
},
})
AddFuncLookup("minecraftbiome", Info{
Display: "Minecraft biome",
Category: "minecraft",
Description: "Distinctive environmental regions in the game, characterized by unique terrain, vegetation, and weather",
Example: "forest",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return minecraftBiome(r), nil
},
})
AddFuncLookup("minecraftweather", Info{
Display: "Minecraft weather",
Category: "minecraft",
Description: "Atmospheric conditions in the game that include rain, thunderstorms, and clear skies, affecting gameplay and ambiance",
Example: "rain",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return minecraftWeather(r), nil
},
})
}

168
vendor/github.com/brianvoe/gofakeit/v6/misc.go generated vendored Normal file
View File

@ -0,0 +1,168 @@
package gofakeit
import (
"encoding/hex"
"math/rand"
"reflect"
"github.com/brianvoe/gofakeit/v6/data"
)
// Bool will generate a random boolean value
func Bool() bool { return boolFunc(globalFaker.Rand) }
// Bool will generate a random boolean value
func (f *Faker) Bool() bool { return boolFunc(f.Rand) }
func boolFunc(r *rand.Rand) bool { return randIntRange(r, 0, 1) == 1 }
// UUID (version 4) will generate a random unique identifier based upon random numbers
// Format: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
func UUID() string { return uuid(globalFaker.Rand) }
// UUID (version 4) will generate a random unique identifier based upon random numbers
// Format: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx 8-4-4-4-12
func (f *Faker) UUID() string { return uuid(f.Rand) }
func uuid(r *rand.Rand) string {
version := byte(4)
uuid := make([]byte, 16)
// Commented out due to io.ReadFull not being race condition safe
// io.ReadFull(r, uuid[:])
// Read 16 random bytes
for i := 0; i < 16; i++ {
uuid[i] = byte(r.Intn(256))
}
// Set version
uuid[6] = (uuid[6] & 0x0f) | (version << 4)
// Set variant
uuid[8] = (uuid[8] & 0xbf) | 0x80
buf := make([]byte, 36)
hex.Encode(buf[0:8], uuid[0:4])
buf[8] = dash
hex.Encode(buf[9:13], uuid[4:6])
buf[13] = dash
hex.Encode(buf[14:18], uuid[6:8])
buf[18] = dash
hex.Encode(buf[19:23], uuid[8:10])
buf[23] = dash
hex.Encode(buf[24:], uuid[10:])
return string(buf)
}
// ShuffleAnySlice takes in a slice and outputs it in a random order
func ShuffleAnySlice(v any) { shuffleAnySlice(globalFaker.Rand, v) }
// ShuffleAnySlice takes in a slice and outputs it in a random order
func (f *Faker) ShuffleAnySlice(v any) { shuffleAnySlice(f.Rand, v) }
func shuffleAnySlice(r *rand.Rand, v any) {
if v == nil {
return
}
// Check type of passed in value, if not a slice return with no action taken
typ := reflect.TypeOf(v)
if typ.Kind() != reflect.Slice {
return
}
s := reflect.ValueOf(v)
n := s.Len()
if n <= 1 {
return
}
swap := func(i, j int) {
tmp := reflect.ValueOf(s.Index(i).Interface())
s.Index(i).Set(s.Index(j))
s.Index(j).Set(tmp)
}
//if size is > int32 probably it will never finish, or ran out of entropy
i := n - 1
for ; i > 0; i-- {
j := int(r.Int31n(int32(i + 1)))
swap(i, j)
}
}
// FlipACoin will return a random value of Heads or Tails
func FlipACoin() string { return flipACoin(globalFaker.Rand) }
// FlipACoin will return a random value of Heads or Tails
func (f *Faker) FlipACoin() string { return flipACoin(f.Rand) }
func flipACoin(r *rand.Rand) string {
if boolFunc(r) {
return "Heads"
}
return "Tails"
}
// RandomMapKey will return a random key from a map
func RandomMapKey(mapI any) any { return randomMapKey(globalFaker.Rand, mapI) }
// RandomMapKey will return a random key from a map
func (f *Faker) RandomMapKey(mapI any) any { return randomMapKey(f.Rand, mapI) }
func randomMapKey(r *rand.Rand, mapI any) any {
keys := reflect.ValueOf(mapI).MapKeys()
return keys[r.Intn(len(keys))].Interface()
}
// Categories will return a map string array of available data categories and sub categories
func Categories() map[string][]string {
types := make(map[string][]string)
for category, subCategoriesMap := range data.Data {
subCategories := make([]string, 0)
for subType := range subCategoriesMap {
subCategories = append(subCategories, subType)
}
types[category] = subCategories
}
return types
}
func addMiscLookup() {
AddFuncLookup("uuid", Info{
Display: "UUID",
Category: "misc",
Description: "128-bit identifier used to uniquely identify objects or entities in computer systems",
Example: "590c1440-9888-45b0-bd51-a817ee07c3f2",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return uuid(r), nil
},
})
AddFuncLookup("bool", Info{
Display: "Boolean",
Category: "misc",
Description: "Data type that represents one of two possible values, typically true or false",
Example: "true",
Output: "bool",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return boolFunc(r), nil
},
})
AddFuncLookup("flipacoin", Info{
Display: "Flip A Coin",
Category: "misc",
Description: "Decision-making method involving the tossing of a coin to determine outcomes",
Example: "Tails",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return flipACoin(r), nil
},
})
}

70
vendor/github.com/brianvoe/gofakeit/v6/movie.go generated vendored Normal file
View File

@ -0,0 +1,70 @@
package gofakeit
import "math/rand"
func MovieName() string { return movieName(globalFaker.Rand) }
func (f *Faker) MovieName() string { return movieName(f.Rand) }
func movieName(r *rand.Rand) string { return getRandValue(r, []string{"movie", "name"}) }
func MovieGenre() string { return movieGenre(globalFaker.Rand) }
func (f *Faker) MovieGenre() string { return movieGenre(f.Rand) }
func movieGenre(r *rand.Rand) string { return getRandValue(r, []string{"movie", "genre"}) }
type MovieInfo struct {
Name string `json:"name" xml:"name"`
Genre string `json:"genre" xml:"genre"`
}
func Movie() *MovieInfo { return movie(globalFaker.Rand) }
func (f *Faker) Movie() *MovieInfo { return movie(f.Rand) }
func movie(r *rand.Rand) *MovieInfo {
return &MovieInfo{
Name: movieName(r),
Genre: movieGenre(r),
}
}
func addMovieLookup() {
AddFuncLookup("movie", Info{
Display: "Movie",
Category: "movie",
Description: "A story told through moving pictures and sound",
Example: `{
"name": "Psycho",
"genre": "Mystery"
}`,
Output: "map[string]string",
ContentType: "application/json",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return movie(r), nil
},
})
AddFuncLookup("moviename", Info{
Display: "Movie Name",
Category: "movie",
Description: "Title or name of a specific film used for identification and reference",
Example: "The Matrix",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return movieName(r), nil
},
})
AddFuncLookup("moviegenre", Info{
Display: "Genre",
Category: "movie",
Description: "Category that classifies movies based on common themes, styles, and storytelling approaches",
Example: "Action",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return movieGenre(r), nil
},
})
}

612
vendor/github.com/brianvoe/gofakeit/v6/number.go generated vendored Normal file
View File

@ -0,0 +1,612 @@
package gofakeit
import (
"math"
"math/rand"
)
// Number will generate a random number between given min And max
func Number(min int, max int) int { return number(globalFaker.Rand, min, max) }
// Number will generate a random number between given min And max
func (f *Faker) Number(min int, max int) int { return number(f.Rand, min, max) }
func number(r *rand.Rand, min int, max int) int { return randIntRange(r, min, max) }
// Uint8 will generate a random uint8 value
func Uint8() uint8 { return uint8Func(globalFaker.Rand) }
// Uint8 will generate a random uint8 value
func (f *Faker) Uint8() uint8 { return uint8Func(f.Rand) }
func uint8Func(r *rand.Rand) uint8 { return uint8(randUintRange(r, minUint, math.MaxUint8)) }
// Uint16 will generate a random uint16 value
func Uint16() uint16 { return uint16Func(globalFaker.Rand) }
// Uint16 will generate a random uint16 value
func (f *Faker) Uint16() uint16 { return uint16Func(f.Rand) }
func uint16Func(r *rand.Rand) uint16 { return uint16(randUintRange(r, minUint, math.MaxUint16)) }
// Uint32 will generate a random uint32 value
func Uint32() uint32 { return uint32Func(globalFaker.Rand) }
// Uint32 will generate a random uint32 value
func (f *Faker) Uint32() uint32 { return uint32Func(f.Rand) }
func uint32Func(r *rand.Rand) uint32 { return uint32(randUintRange(r, minUint, math.MaxUint32)) }
// Uint64 will generate a random uint64 value
func Uint64() uint64 { return uint64Func(globalFaker.Rand) }
// Uint64 will generate a random uint64 value
func (f *Faker) Uint64() uint64 { return uint64Func(f.Rand) }
func uint64Func(r *rand.Rand) uint64 { return uint64(randUintRange(r, minUint, maxUint)) }
// UintRange will generate a random uint value between min and max
func UintRange(min, max uint) uint { return uintRangeFunc(globalFaker.Rand, min, max) }
// UintRange will generate a random uint value between min and max
func (f *Faker) UintRange(min, max uint) uint { return uintRangeFunc(f.Rand, min, max) }
func uintRangeFunc(r *rand.Rand, min, max uint) uint { return randUintRange(r, min, max) }
// Int8 will generate a random Int8 value
func Int8() int8 { return int8Func(globalFaker.Rand) }
// Int8 will generate a random Int8 value
func (f *Faker) Int8() int8 { return int8Func(f.Rand) }
func int8Func(r *rand.Rand) int8 { return int8(randIntRange(r, math.MinInt8, math.MaxInt8)) }
// Int16 will generate a random int16 value
func Int16() int16 { return int16Func(globalFaker.Rand) }
// Int16 will generate a random int16 value
func (f *Faker) Int16() int16 { return int16Func(f.Rand) }
func int16Func(r *rand.Rand) int16 { return int16(randIntRange(r, math.MinInt16, math.MaxInt16)) }
// Int32 will generate a random int32 value
func Int32() int32 { return int32Func(globalFaker.Rand) }
// Int32 will generate a random int32 value
func (f *Faker) Int32() int32 { return int32Func(f.Rand) }
func int32Func(r *rand.Rand) int32 { return int32(randIntRange(r, math.MinInt32, math.MaxInt32)) }
// Int64 will generate a random int64 value
func Int64() int64 { return int64Func(globalFaker.Rand) }
// Int64 will generate a random int64 value
func (f *Faker) Int64() int64 { return int64Func(f.Rand) }
func int64Func(r *rand.Rand) int64 { return int64(randIntRange(r, minInt, maxInt)) }
// IntRange will generate a random int value between min and max
func IntRange(min, max int) int { return intRangeFunc(globalFaker.Rand, min, max) }
// IntRange will generate a random int value between min and max
func (f *Faker) IntRange(min, max int) int { return intRangeFunc(f.Rand, min, max) }
func intRangeFunc(r *rand.Rand, min, max int) int { return randIntRange(r, min, max) }
// Float32 will generate a random float32 value
func Float32() float32 { return float32Func(globalFaker.Rand) }
// Float32 will generate a random float32 value
func (f *Faker) Float32() float32 { return float32Func(f.Rand) }
func float32Func(r *rand.Rand) float32 {
return float32Range(r, math.SmallestNonzeroFloat32, math.MaxFloat32)
}
// Float32Range will generate a random float32 value between min and max
func Float32Range(min, max float32) float32 {
return float32Range(globalFaker.Rand, min, max)
}
// Float32Range will generate a random float32 value between min and max
func (f *Faker) Float32Range(min, max float32) float32 {
return float32Range(f.Rand, min, max)
}
func float32Range(r *rand.Rand, min, max float32) float32 {
if min == max {
return min
}
return r.Float32()*(max-min) + min
}
// Float64 will generate a random float64 value
func Float64() float64 {
return float64Func(globalFaker.Rand)
}
// Float64 will generate a random float64 value
func (f *Faker) Float64() float64 {
return float64Func(f.Rand)
}
func float64Func(r *rand.Rand) float64 {
return float64Range(r, math.SmallestNonzeroFloat64, math.MaxFloat64)
}
// Float64Range will generate a random float64 value between min and max
func Float64Range(min, max float64) float64 {
return float64Range(globalFaker.Rand, min, max)
}
// Float64Range will generate a random float64 value between min and max
func (f *Faker) Float64Range(min, max float64) float64 {
return float64Range(f.Rand, min, max)
}
func float64Range(r *rand.Rand, min, max float64) float64 {
if min == max {
return min
}
return r.Float64()*(max-min) + min
}
// ShuffleInts will randomize a slice of ints
func ShuffleInts(a []int) { shuffleInts(globalFaker.Rand, a) }
// ShuffleInts will randomize a slice of ints
func (f *Faker) ShuffleInts(a []int) { shuffleInts(f.Rand, a) }
func shuffleInts(r *rand.Rand, a []int) {
for i := range a {
j := r.Intn(i + 1)
a[i], a[j] = a[j], a[i]
}
}
// RandomInt will take in a slice of int and return a randomly selected value
func RandomInt(i []int) int { return randomInt(globalFaker.Rand, i) }
// RandomInt will take in a slice of int and return a randomly selected value
func (f *Faker) RandomInt(i []int) int { return randomInt(f.Rand, i) }
func randomInt(r *rand.Rand, i []int) int {
size := len(i)
if size == 0 {
return 0
}
if size == 1 {
return i[0]
}
return i[r.Intn(size)]
}
// RandomUint will take in a slice of uint and return a randomly selected value
func RandomUint(u []uint) uint { return randomUint(globalFaker.Rand, u) }
// RandomUint will take in a slice of uint and return a randomly selected value
func (f *Faker) RandomUint(u []uint) uint { return randomUint(f.Rand, u) }
func randomUint(r *rand.Rand, u []uint) uint {
size := len(u)
if size == 0 {
return 0
}
if size == 1 {
return u[0]
}
return u[r.Intn(size)]
}
// HexUint8 will generate a random uint8 hex value with "0x" prefix
func HexUint8() string { return hexUint(globalFaker.Rand, 8) }
// HexUint8 will generate a random uint8 hex value with "0x" prefix
func (f *Faker) HexUint8() string { return hexUint(f.Rand, 8) }
// HexUint16 will generate a random uint16 hex value with "0x" prefix
func HexUint16() string { return hexUint(globalFaker.Rand, 16) }
// HexUint16 will generate a random uint16 hex value with "0x" prefix
func (f *Faker) HexUint16() string { return hexUint(f.Rand, 16) }
// HexUint32 will generate a random uint32 hex value with "0x" prefix
func HexUint32() string { return hexUint(globalFaker.Rand, 32) }
// HexUint32 will generate a random uint32 hex value with "0x" prefix
func (f *Faker) HexUint32() string { return hexUint(f.Rand, 32) }
// HexUint64 will generate a random uint64 hex value with "0x" prefix
func HexUint64() string { return hexUint(globalFaker.Rand, 64) }
// HexUint64 will generate a random uint64 hex value with "0x" prefix
func (f *Faker) HexUint64() string { return hexUint(f.Rand, 64) }
// HexUint128 will generate a random uint128 hex value with "0x" prefix
func HexUint128() string { return hexUint(globalFaker.Rand, 128) }
// HexUint128 will generate a random uint128 hex value with "0x" prefix
func (f *Faker) HexUint128() string { return hexUint(f.Rand, 128) }
// HexUint256 will generate a random uint256 hex value with "0x" prefix
func HexUint256() string { return hexUint(globalFaker.Rand, 256) }
// HexUint256 will generate a random uint256 hex value with "0x" prefix
func (f *Faker) HexUint256() string { return hexUint(f.Rand, 256) }
func hexUint(r *rand.Rand, bitSize int) string {
digits := []byte("0123456789abcdef")
hexLen := (bitSize >> 2) + 2
if hexLen <= 2 {
return "0x"
}
s := make([]byte, hexLen)
s[0], s[1] = '0', 'x'
for i := 2; i < hexLen; i++ {
s[i] = digits[r.Intn(16)]
}
return string(s)
}
func addNumberLookup() {
AddFuncLookup("number", Info{
Display: "Number",
Category: "number",
Description: "Mathematical concept used for counting, measuring, and expressing quantities or values",
Example: "14866",
Output: "int",
Params: []Param{
{Field: "min", Display: "Min", Type: "int", Default: "-2147483648", Description: "Minimum integer value"},
{Field: "max", Display: "Max", Type: "int", Default: "2147483647", Description: "Maximum integer value"},
},
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
min, err := info.GetInt(m, "min")
if err != nil {
return nil, err
}
max, err := info.GetInt(m, "max")
if err != nil {
return nil, err
}
return number(r, min, max), nil
},
})
AddFuncLookup("uint8", Info{
Display: "Uint8",
Category: "number",
Description: "Unsigned 8-bit integer, capable of representing values from 0 to 255",
Example: "152",
Output: "uint8",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return uint8Func(r), nil
},
})
AddFuncLookup("uint16", Info{
Display: "Uint16",
Category: "number",
Description: "Unsigned 16-bit integer, capable of representing values from 0 to 65,535",
Example: "34968",
Output: "uint16",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return uint16Func(r), nil
},
})
AddFuncLookup("uint32", Info{
Display: "Uint32",
Category: "number",
Description: "Unsigned 32-bit integer, capable of representing values from 0 to 4,294,967,295",
Example: "1075055705",
Output: "uint32",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return uint32Func(r), nil
},
})
AddFuncLookup("uint64", Info{
Display: "Uint64",
Category: "number",
Description: "Unsigned 64-bit integer, capable of representing values from 0 to 18,446,744,073,709,551,615",
Example: "843730692693298265",
Output: "uint64",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return uint64Func(r), nil
},
})
AddFuncLookup("uintrange", Info{
Display: "UintRange",
Category: "number",
Description: "Non-negative integer value between given range",
Example: "1075055705",
Output: "uint",
Params: []Param{
{Field: "min", Display: "Min", Type: "uint", Default: "0", Description: "Minimum uint value"},
{Field: "max", Display: "Max", Type: "uint", Default: "4294967295", Description: "Maximum uint value"},
},
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
min, err := info.GetUint(m, "min")
if err != nil {
return nil, err
}
max, err := info.GetUint(m, "max")
if err != nil {
return nil, err
}
return uintRangeFunc(r, min, max), nil
},
})
AddFuncLookup("int8", Info{
Display: "Int8",
Category: "number",
Description: "Signed 8-bit integer, capable of representing values from -128 to 127",
Example: "24",
Output: "int8",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return int8Func(r), nil
},
})
AddFuncLookup("int16", Info{
Display: "Int16",
Category: "number",
Description: "Signed 16-bit integer, capable of representing values from 32,768 to 32,767",
Example: "2200",
Output: "int16",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return int16Func(r), nil
},
})
AddFuncLookup("int32", Info{
Display: "Int32",
Category: "number",
Description: "Signed 32-bit integer, capable of representing values from -2,147,483,648 to 2,147,483,647",
Example: "-1072427943",
Output: "int32",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return int32Func(r), nil
},
})
AddFuncLookup("int64", Info{
Display: "Int64",
Category: "number",
Description: "Signed 64-bit integer, capable of representing values from -9,223,372,036,854,775,808 to -9,223,372,036,854,775,807",
Example: "-8379641344161477543",
Output: "int64",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return int64Func(r), nil
},
})
AddFuncLookup("intrange", Info{
Display: "IntRange",
Category: "number",
Description: "Integer value between given range",
Example: "-8379477543",
Output: "int",
Params: []Param{
{Field: "min", Display: "Min", Type: "int", Description: "Minimum int value"},
{Field: "max", Display: "Max", Type: "int", Description: "Maximum int value"},
},
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
min, err := info.GetInt(m, "min")
if err != nil {
return nil, err
}
max, err := info.GetInt(m, "max")
if err != nil {
return nil, err
}
return intRangeFunc(r, min, max), nil
},
})
AddFuncLookup("float32", Info{
Display: "Float32",
Category: "number",
Description: "Data type representing floating-point numbers with 32 bits of precision in computing",
Example: "3.1128167e+37",
Output: "float32",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return float32Func(r), nil
},
})
AddFuncLookup("float32range", Info{
Display: "Float32 Range",
Category: "number",
Description: "Float32 value between given range",
Example: "914774.6",
Output: "float32",
Params: []Param{
{Field: "min", Display: "Min", Type: "float", Description: "Minimum float32 value"},
{Field: "max", Display: "Max", Type: "float", Description: "Maximum float32 value"},
},
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
min, err := info.GetFloat32(m, "min")
if err != nil {
return nil, err
}
max, err := info.GetFloat32(m, "max")
if err != nil {
return nil, err
}
return float32Range(r, min, max), nil
},
})
AddFuncLookup("float64", Info{
Display: "Float64",
Category: "number",
Description: "Data type representing floating-point numbers with 64 bits of precision in computing",
Example: "1.644484108270445e+307",
Output: "float64",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return float64Func(r), nil
},
})
AddFuncLookup("float64range", Info{
Display: "Float64 Range",
Category: "number",
Description: "Float64 value between given range",
Example: "914774.5585333086",
Output: "float64",
Params: []Param{
{Field: "min", Display: "Min", Type: "float", Description: "Minimum float64 value"},
{Field: "max", Display: "Max", Type: "float", Description: "Maximum float64 value"},
},
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
min, err := info.GetFloat64(m, "min")
if err != nil {
return nil, err
}
max, err := info.GetFloat64(m, "max")
if err != nil {
return nil, err
}
return float64Range(r, min, max), nil
},
})
AddFuncLookup("shuffleints", Info{
Display: "Shuffle Ints",
Category: "number",
Description: "Shuffles an array of ints",
Example: "1,2,3,4 => 3,1,4,2",
Output: "[]int",
Params: []Param{
{Field: "ints", Display: "Integers", Type: "[]int", Description: "Delimited separated integers"},
},
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
ints, err := info.GetIntArray(m, "ints")
if err != nil {
return nil, err
}
shuffleInts(r, ints)
return ints, nil
},
})
AddFuncLookup("randomint", Info{
Display: "Random Int",
Category: "number",
Description: "Randomly selected value from a slice of int",
Example: "-1,2,-3,4 => -3",
Output: "int",
Params: []Param{
{Field: "ints", Display: "Integers", Type: "[]int", Description: "Delimited separated integers"},
},
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
ints, err := info.GetIntArray(m, "ints")
if err != nil {
return nil, err
}
return randomInt(r, ints), nil
},
})
AddFuncLookup("randomuint", Info{
Display: "Random Uint",
Category: "number",
Description: "Randomly selected value from a slice of uint",
Example: "1,2,3,4 => 4",
Output: "uint",
Params: []Param{
{Field: "uints", Display: "Unsigned Integers", Type: "[]uint", Description: "Delimited separated unsigned integers"},
},
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
uints, err := info.GetUintArray(m, "uints")
if err != nil {
return nil, err
}
return randomUint(r, uints), nil
},
})
AddFuncLookup("hexuint8", Info{
Display: "HexUint8",
Category: "number",
Description: "Hexadecimal representation of an 8-bit unsigned integer",
Example: "0x87",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return hexUint(r, 8), nil
},
})
AddFuncLookup("hexuint16", Info{
Display: "HexUint16",
Category: "number",
Description: "Hexadecimal representation of an 16-bit unsigned integer",
Example: "0x8754",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return hexUint(r, 16), nil
},
})
AddFuncLookup("hexuint32", Info{
Display: "HexUint32",
Category: "number",
Description: "Hexadecimal representation of an 32-bit unsigned integer",
Example: "0x87546957",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return hexUint(r, 32), nil
},
})
AddFuncLookup("hexuint64", Info{
Display: "HexUint64",
Category: "number",
Description: "Hexadecimal representation of an 64-bit unsigned integer",
Example: "0x875469578e51b5e5",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return hexUint(r, 64), nil
},
})
AddFuncLookup("hexuint128", Info{
Display: "HexUint128",
Category: "number",
Description: "Hexadecimal representation of an 128-bit unsigned integer",
Example: "0x875469578e51b5e56c95b64681d147a1",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return hexUint(r, 128), nil
},
})
AddFuncLookup("hexuint256", Info{
Display: "HexUint256",
Category: "number",
Description: "Hexadecimal representation of an 256-bit unsigned integer",
Example: "0x875469578e51b5e56c95b64681d147a12cde48a4f417231b0c486abbc263e48d",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return hexUint(r, 256), nil
},
})
}

442
vendor/github.com/brianvoe/gofakeit/v6/payment.go generated vendored Normal file
View File

@ -0,0 +1,442 @@
package gofakeit
import (
"math"
"math/rand"
"strconv"
"strings"
"time"
"github.com/brianvoe/gofakeit/v6/data"
)
// CurrencyInfo is a struct of currency information
type CurrencyInfo struct {
Short string `json:"short" xml:"short"`
Long string `json:"long" xml:"long"`
}
// Currency will generate a struct with random currency information
func Currency() *CurrencyInfo { return currency(globalFaker.Rand) }
// Currency will generate a struct with random currency information
func (f *Faker) Currency() *CurrencyInfo { return currency(f.Rand) }
func currency(r *rand.Rand) *CurrencyInfo {
index := r.Intn(len(data.Data["currency"]["short"]))
return &CurrencyInfo{
Short: data.Data["currency"]["short"][index],
Long: data.Data["currency"]["long"][index],
}
}
// CurrencyShort will generate a random short currency value
func CurrencyShort() string { return currencyShort(globalFaker.Rand) }
// CurrencyShort will generate a random short currency value
func (f *Faker) CurrencyShort() string { return currencyShort(f.Rand) }
func currencyShort(r *rand.Rand) string { return getRandValue(r, []string{"currency", "short"}) }
// CurrencyLong will generate a random long currency name
func CurrencyLong() string { return currencyLong(globalFaker.Rand) }
// CurrencyLong will generate a random long currency name
func (f *Faker) CurrencyLong() string { return currencyLong(f.Rand) }
func currencyLong(r *rand.Rand) string { return getRandValue(r, []string{"currency", "long"}) }
// Price will take in a min and max value and return a formatted price
func Price(min, max float64) float64 { return price(globalFaker.Rand, min, max) }
// Price will take in a min and max value and return a formatted price
func (f *Faker) Price(min, max float64) float64 { return price(f.Rand, min, max) }
func price(r *rand.Rand, min, max float64) float64 {
return math.Floor(float64Range(r, min, max)*100) / 100
}
// CreditCardInfo is a struct containing credit variables
type CreditCardInfo struct {
Type string `json:"type" xml:"type"`
Number string `json:"number" xml:"number"`
Exp string `json:"exp" xml:"exp"`
Cvv string `json:"cvv" xml:"cvv"`
}
// CreditCard will generate a struct full of credit card information
func CreditCard() *CreditCardInfo { return creditCard(globalFaker.Rand) }
// CreditCard will generate a struct full of credit card information
func (f *Faker) CreditCard() *CreditCardInfo { return creditCard(f.Rand) }
func creditCard(r *rand.Rand) *CreditCardInfo {
ccType := randomString(r, data.CreditCardTypes)
return &CreditCardInfo{
Type: data.CreditCards[randomString(r, data.CreditCardTypes)].Display,
Number: creditCardNumber(r, &CreditCardOptions{Types: []string{ccType}}),
Exp: creditCardExp(r),
Cvv: generate(r, strings.Repeat("#", int(data.CreditCards[randomString(r, data.CreditCardTypes)].Code.Size))),
}
}
// CreditCardType will generate a random credit card type string
func CreditCardType() string { return creditCardType(globalFaker.Rand) }
// CreditCardType will generate a random credit card type string
func (f *Faker) CreditCardType() string { return creditCardType(f.Rand) }
func creditCardType(r *rand.Rand) string {
return data.CreditCards[randomString(r, data.CreditCardTypes)].Display
}
// CreditCardOptions is the options for credit card number
type CreditCardOptions struct {
Types []string `json:"types"`
Bins []string `json:"bins"` // optional parameter of prepended numbers
Gaps bool `json:"gaps"`
}
// CreditCardNumber will generate a random luhn credit card number
func CreditCardNumber(cco *CreditCardOptions) string { return creditCardNumber(globalFaker.Rand, cco) }
// CreditCardNumber will generate a random luhn credit card number
func (f *Faker) CreditCardNumber(cco *CreditCardOptions) string { return creditCardNumber(f.Rand, cco) }
func creditCardNumber(r *rand.Rand, cco *CreditCardOptions) string {
if cco == nil {
cco = &CreditCardOptions{}
}
if cco.Types == nil || len(cco.Types) == 0 {
cco.Types = data.CreditCardTypes
}
ccType := randomString(r, cco.Types)
// Get Card info
var cardInfo data.CreditCardInfo
if info, ok := data.CreditCards[ccType]; ok {
cardInfo = info
} else {
ccType = randomString(r, data.CreditCardTypes)
cardInfo = data.CreditCards[ccType]
}
// Get length and pattern
length := randomUint(r, cardInfo.Lengths)
numStr := ""
if len(cco.Bins) >= 1 {
numStr = randomString(r, cco.Bins)
} else {
numStr = strconv.FormatUint(uint64(randomUint(r, cardInfo.Patterns)), 10)
}
numStr += strings.Repeat("#", int(length)-len(numStr))
numStr = numerify(r, numStr)
ui, _ := strconv.ParseUint(numStr, 10, 64)
// Loop through until its a valid luhn
for {
valid := isLuhn(strconv.FormatUint(ui, 10))
if valid {
break
}
ui++
}
numStr = strconv.FormatUint(ui, 10)
// Add gaps to number
if cco.Gaps {
for i, spot := range cardInfo.Gaps {
numStr = numStr[:(int(spot)+i)] + " " + numStr[(int(spot)+i):]
}
}
return numStr
}
// CreditCardExp will generate a random credit card expiration date string
// Exp date will always be a future date
func CreditCardExp() string { return creditCardExp(globalFaker.Rand) }
// CreditCardExp will generate a random credit card expiration date string
// Exp date will always be a future date
func (f *Faker) CreditCardExp() string { return creditCardExp(f.Rand) }
func creditCardExp(r *rand.Rand) string {
month := strconv.Itoa(randIntRange(r, 1, 12))
if len(month) == 1 {
month = "0" + month
}
var currentYear = time.Now().Year() - 2000
return month + "/" + strconv.Itoa(randIntRange(r, currentYear+1, currentYear+10))
}
// CreditCardCvv will generate a random CVV number
// Its a string because you could have 017 as an exp date
func CreditCardCvv() string { return creditCardCvv(globalFaker.Rand) }
// CreditCardCvv will generate a random CVV number
// Its a string because you could have 017 as an exp date
func (f *Faker) CreditCardCvv() string { return creditCardCvv(f.Rand) }
func creditCardCvv(r *rand.Rand) string { return numerify(r, "###") }
// isLuhn check is used for checking if credit card is a valid luhn card
func isLuhn(s string) bool {
var t = [...]int{0, 2, 4, 6, 8, 1, 3, 5, 7, 9}
odd := len(s) & 1
var sum int
for i, c := range s {
if c < '0' || c > '9' {
return false
}
if i&1 == odd {
sum += t[c-'0']
} else {
sum += int(c - '0')
}
}
return sum%10 == 0
}
// AchRouting will generate a 9 digit routing number
func AchRouting() string { return achRouting(globalFaker.Rand) }
// AchRouting will generate a 9 digit routing number
func (f *Faker) AchRouting() string { return achRouting(f.Rand) }
func achRouting(r *rand.Rand) string { return numerify(r, "#########") }
// AchAccount will generate a 12 digit account number
func AchAccount() string { return achAccount(globalFaker.Rand) }
// AchAccount will generate a 12 digit account number
func (f *Faker) AchAccount() string { return achAccount(f.Rand) }
func achAccount(r *rand.Rand) string { return numerify(r, "############") }
// BitcoinAddress will generate a random bitcoin address consisting of numbers, upper and lower characters
func BitcoinAddress() string { return bitcoinAddress(globalFaker.Rand) }
// BitcoinAddress will generate a random bitcoin address consisting of numbers, upper and lower characters
func (f *Faker) BitcoinAddress() string { return bitcoinAddress(f.Rand) }
func bitcoinAddress(r *rand.Rand) string {
return randomString(r, []string{"1", "3"}) + password(r, true, true, true, false, false, number(r, 25, 34))
}
// BitcoinPrivateKey will generate a random bitcoin private key base58 consisting of numbers, upper and lower characters
func BitcoinPrivateKey() string { return bitcoinPrivateKey(globalFaker.Rand) }
// BitcoinPrivateKey will generate a random bitcoin private key base58 consisting of numbers, upper and lower characters
func (f *Faker) BitcoinPrivateKey() string { return bitcoinPrivateKey(f.Rand) }
func bitcoinPrivateKey(r *rand.Rand) string {
var b strings.Builder
for i := 0; i < 49; i++ {
b.WriteString(randCharacter(r, base58))
}
return "5" + randomString(r, []string{"H", "J", "K"}) + b.String()
}
func addPaymentLookup() {
AddFuncLookup("currency", Info{
Display: "Currency",
Category: "payment",
Description: "Medium of exchange, often in the form of paper money or coins, used for trade and transactions",
Example: `{
"short": "IQD",
"long": "Iraq Dinar"
}`,
Output: "map[string]string",
ContentType: "application/json",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return currency(r), nil
},
})
AddFuncLookup("currencyshort", Info{
Display: "Currency Short",
Category: "payment",
Description: "Short 3-letter word used to represent a specific currency",
Example: "USD",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return currencyShort(r), nil
},
})
AddFuncLookup("currencylong", Info{
Display: "Currency Long",
Category: "payment",
Description: "Complete name of a specific currency used for official identification in financial transactions",
Example: "United States Dollar",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return currencyLong(r), nil
},
})
AddFuncLookup("price", Info{
Display: "Price",
Category: "payment",
Description: "The amount of money or value assigned to a product, service, or asset in a transaction",
Example: "92.26",
Output: "float64",
Params: []Param{
{Field: "min", Display: "Min", Type: "float", Default: "0", Description: "Minimum price value"},
{Field: "max", Display: "Max", Type: "float", Default: "1000", Description: "Maximum price value"},
},
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
min, err := info.GetFloat64(m, "min")
if err != nil {
return nil, err
}
max, err := info.GetFloat64(m, "max")
if err != nil {
return nil, err
}
return price(r, min, max), nil
},
})
AddFuncLookup("creditcard", Info{
Display: "Credit Card",
Category: "payment",
Description: "Plastic card allowing users to make purchases on credit, with payment due at a later date",
Example: `{
"type": "UnionPay",
"number": "4364599489953698",
"exp": "02/24",
"cvv": "300"
}`,
Output: "map[string]any",
ContentType: "application/json",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return creditCard(r), nil
},
})
AddFuncLookup("creditcardtype", Info{
Display: "Credit Card Type",
Category: "payment",
Description: "Classification of credit cards based on the issuing company",
Example: "Visa",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return creditCardType(r), nil
},
})
AddFuncLookup("creditcardnumber", Info{
Display: "Credit Card Number",
Category: "payment",
Description: "Unique numerical identifier on a credit card used for making electronic payments and transactions",
Example: "4136459948995369",
Output: "string",
Params: []Param{
{
Field: "types", Display: "Types", Type: "[]string", Default: "all",
Options: []string{"visa", "mastercard", "american-express", "diners-club", "discover", "jcb", "unionpay", "maestro", "elo", "hiper", "hipercard"},
Description: "A select number of types you want to use when generating a credit card number",
},
{Field: "bins", Display: "Bins", Type: "[]string", Optional: true, Description: "Optional list of prepended bin numbers to pick from"},
{Field: "gaps", Display: "Gaps", Type: "bool", Default: "false", Description: "Whether or not to have gaps in number"},
},
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
types, err := info.GetStringArray(m, "types")
if err != nil {
return nil, err
}
if len(types) == 1 && types[0] == "all" {
types = []string{}
}
bins, _ := info.GetStringArray(m, "bins")
gaps, err := info.GetBool(m, "gaps")
if err != nil {
return nil, err
}
options := CreditCardOptions{
Types: types,
Gaps: gaps,
}
if len(bins) >= 1 {
options.Bins = bins
}
return creditCardNumber(r, &options), nil
},
})
AddFuncLookup("creditcardexp", Info{
Display: "Credit Card Exp",
Category: "payment",
Description: "Date when a credit card becomes invalid and cannot be used for transactions",
Example: "01/21",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return creditCardExp(r), nil
},
})
AddFuncLookup("creditcardcvv", Info{
Display: "Credit Card CVV",
Category: "payment",
Description: "Three or four-digit security code on a credit card used for online and remote transactions",
Example: "513",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return creditCardCvv(r), nil
},
})
AddFuncLookup("achrouting", Info{
Display: "ACH Routing Number",
Category: "payment",
Description: "Unique nine-digit code used in the U.S. for identifying the bank and processing electronic transactions",
Example: "513715684",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return achRouting(r), nil
},
})
AddFuncLookup("achaccount", Info{
Display: "ACH Account Number",
Category: "payment",
Description: "A bank account number used for Automated Clearing House transactions and electronic transfers",
Example: "491527954328",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return achAccount(r), nil
},
})
AddFuncLookup("bitcoinaddress", Info{
Display: "Bitcoin Address",
Category: "payment",
Description: "Cryptographic identifier used to receive, store, and send Bitcoin cryptocurrency in a peer-to-peer network",
Example: "1lWLbxojXq6BqWX7X60VkcDIvYA",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return bitcoinAddress(r), nil
},
})
AddFuncLookup("bitcoinprivatekey", Info{
Display: "Bitcoin Private Key",
Category: "payment",
Description: "Secret, secure code that allows the owner to access and control their Bitcoin holdings",
Example: "5vrbXTADWJ6sQBSYd6lLkG97jljNc0X9VPBvbVqsIH9lWOLcoqg",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return bitcoinPrivateKey(r), nil
},
})
}

426
vendor/github.com/brianvoe/gofakeit/v6/person.go generated vendored Normal file
View File

@ -0,0 +1,426 @@
package gofakeit
import (
"math"
"math/rand"
"strconv"
"strings"
)
// PersonInfo is a struct of person information
type PersonInfo struct {
FirstName string `json:"first_name" xml:"first_name"`
LastName string `json:"last_name" xml:"last_name"`
Gender string `json:"gender" xml:"gender"`
SSN string `json:"ssn" xml:"ssn"`
Image string `json:"image" xml:"image"`
Hobby string `json:"hobby" xml:"hobby"`
Job *JobInfo `json:"job" xml:"job"`
Address *AddressInfo `json:"address" xml:"address"`
Contact *ContactInfo `json:"contact" xml:"contact"`
CreditCard *CreditCardInfo `json:"credit_card" xml:"credit_card"`
}
// Person will generate a struct with person information
func Person() *PersonInfo { return person(globalFaker.Rand) }
// Person will generate a struct with person information
func (f *Faker) Person() *PersonInfo { return person(f.Rand) }
func person(r *rand.Rand) *PersonInfo {
return &PersonInfo{
FirstName: firstName(r),
LastName: lastName(r),
Gender: gender(r),
SSN: ssn(r),
Image: imageURL(r, number(r, 100, 500), number(r, 100, 500)),
Hobby: hobby(r),
Job: job(r),
Address: address(r),
Contact: contact(r),
CreditCard: creditCard(r),
}
}
// Name will generate a random First and Last Name
func Name() string { return name(globalFaker.Rand) }
// Name will generate a random First and Last Name
func (f *Faker) Name() string { return name(f.Rand) }
func name(r *rand.Rand) string {
return getRandValue(r, []string{"person", "first"}) + " " + getRandValue(r, []string{"person", "last"})
}
// FirstName will generate a random first name
func FirstName() string { return firstName(globalFaker.Rand) }
// FirstName will generate a random first name
func (f *Faker) FirstName() string { return firstName(f.Rand) }
func firstName(r *rand.Rand) string { return getRandValue(r, []string{"person", "first"}) }
// MiddleName will generate a random middle name
func MiddleName() string { return middleName(globalFaker.Rand) }
// MiddleName will generate a random middle name
func (f *Faker) MiddleName() string { return middleName(f.Rand) }
func middleName(r *rand.Rand) string { return getRandValue(r, []string{"person", "middle"}) }
// LastName will generate a random last name
func LastName() string { return lastName(globalFaker.Rand) }
// LastName will generate a random last name
func (f *Faker) LastName() string { return lastName(f.Rand) }
func lastName(r *rand.Rand) string { return getRandValue(r, []string{"person", "last"}) }
// NamePrefix will generate a random name prefix
func NamePrefix() string { return namePrefix(globalFaker.Rand) }
// NamePrefix will generate a random name prefix
func (f *Faker) NamePrefix() string { return namePrefix(f.Rand) }
func namePrefix(r *rand.Rand) string { return getRandValue(r, []string{"person", "prefix"}) }
// NameSuffix will generate a random name suffix
func NameSuffix() string { return nameSuffix(globalFaker.Rand) }
// NameSuffix will generate a random name suffix
func (f *Faker) NameSuffix() string { return nameSuffix(f.Rand) }
func nameSuffix(r *rand.Rand) string { return getRandValue(r, []string{"person", "suffix"}) }
// SSN will generate a random Social Security Number
func SSN() string { return ssn(globalFaker.Rand) }
// SSN will generate a random Social Security Number
func (f *Faker) SSN() string { return ssn(f.Rand) }
func ssn(r *rand.Rand) string { return strconv.Itoa(randIntRange(r, 100000000, 999999999)) }
// Gender will generate a random gender string
func Gender() string { return gender(globalFaker.Rand) }
// Gender will generate a random gender string
func (f *Faker) Gender() string { return gender(f.Rand) }
func gender(r *rand.Rand) string {
if boolFunc(r) {
return "male"
}
return "female"
}
// Hobby will generate a random hobby string
func Hobby() string { return hobby(globalFaker.Rand) }
// Hobby will generate a random hobby string
func (f *Faker) Hobby() string { return hobby(f.Rand) }
func hobby(r *rand.Rand) string { return getRandValue(r, []string{"person", "hobby"}) }
// ContactInfo struct full of contact info
type ContactInfo struct {
Phone string `json:"phone" xml:"phone"`
Email string `json:"email" xml:"email"`
}
// Contact will generate a struct with information randomly populated contact information
func Contact() *ContactInfo { return contact(globalFaker.Rand) }
// Contact will generate a struct with information randomly populated contact information
func (f *Faker) Contact() *ContactInfo { return contact(f.Rand) }
func contact(r *rand.Rand) *ContactInfo {
return &ContactInfo{
Phone: phone(r),
Email: email(r),
}
}
// Phone will generate a random phone number string
func Phone() string { return phone(globalFaker.Rand) }
// Phone will generate a random phone number string
func (f *Faker) Phone() string { return phone(f.Rand) }
func phone(r *rand.Rand) string { return replaceWithNumbers(r, "##########") }
// PhoneFormatted will generate a random phone number string
func PhoneFormatted() string { return phoneFormatted(globalFaker.Rand) }
// PhoneFormatted will generate a random phone number string
func (f *Faker) PhoneFormatted() string { return phoneFormatted(f.Rand) }
func phoneFormatted(r *rand.Rand) string {
return replaceWithNumbers(r, getRandValue(r, []string{"person", "phone"}))
}
// Email will generate a random email string
func Email() string { return email(globalFaker.Rand) }
// Email will generate a random email string
func (f *Faker) Email() string { return email(f.Rand) }
func email(r *rand.Rand) string {
email := getRandValue(r, []string{"person", "first"}) + getRandValue(r, []string{"person", "last"})
email += "@"
email += getRandValue(r, []string{"person", "last"}) + "." + getRandValue(r, []string{"internet", "domain_suffix"})
return strings.ToLower(email)
}
// Teams takes in an array of people and team names and randomly places the people into teams as evenly as possible
func Teams(peopleArray []string, teamsArray []string) map[string][]string {
return teams(globalFaker.Rand, peopleArray, teamsArray)
}
// Teams takes in an array of people and team names and randomly places the people into teams as evenly as possible
func (f *Faker) Teams(peopleArray []string, teamsArray []string) map[string][]string {
return teams(f.Rand, peopleArray, teamsArray)
}
func teams(r *rand.Rand, people []string, teams []string) map[string][]string {
// Shuffle the people if more than 1
if len(people) > 1 {
shuffleStrings(r, people)
}
peopleIndex := 0
teamsOutput := make(map[string][]string)
numPer := math.Ceil(float64(len(people)) / float64(len(teams)))
for _, team := range teams {
teamsOutput[team] = []string{}
for i := 0.00; i < numPer; i++ {
if peopleIndex < len(people) {
teamsOutput[team] = append(teamsOutput[team], people[peopleIndex])
peopleIndex++
}
}
}
return teamsOutput
}
func addPersonLookup() {
AddFuncLookup("person", Info{
Display: "Person",
Category: "person",
Description: "Personal data, like name and contact details, used for identification and communication",
Example: `{
"first_name": "Markus",
"last_name": "Moen",
"gender": "male",
"ssn": "275413589",
"image": "https://picsum.photos/208/500",
"hobby": "Lacrosse",
"job": {
"company": "Intermap Technologies",
"title": "Developer",
"descriptor": "Direct",
"level": "Paradigm"
},
"address": {
"address": "369 North Cornerbury, Miami, North Dakota 24259",
"street": "369 North Cornerbury",
"city": "Miami",
"state": "North Dakota",
"zip": "24259",
"country": "Ghana",
"latitude": -6.662595,
"longitude": 23.921575
},
"contact": {
"phone": "3023202027",
"email": "lamarkoelpin@heaney.biz"
},
"credit_card": {
"type": "Maestro",
"number": "39800889982276",
"exp": "01/29",
"cvv": "932"
}
}`,
Output: "map[string]any",
ContentType: "application/json",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return person(r), nil
},
})
AddFuncLookup("name", Info{
Display: "Name",
Category: "person",
Description: "The given and family name of an individual",
Example: "Markus Moen",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return name(r), nil
},
})
AddFuncLookup("nameprefix", Info{
Display: "Name Prefix",
Category: "person",
Description: "A title or honorific added before a person's name",
Example: "Mr.",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return namePrefix(r), nil
},
})
AddFuncLookup("namesuffix", Info{
Display: "Name Suffix",
Category: "person",
Description: "A title or designation added after a person's name",
Example: "Jr.",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return nameSuffix(r), nil
},
})
AddFuncLookup("firstname", Info{
Display: "First Name",
Category: "person",
Description: "The name given to a person at birth",
Example: "Markus",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return firstName(r), nil
},
})
AddFuncLookup("middlename", Info{
Display: "Middle Name",
Category: "person",
Description: "Name between a person's first name and last name",
Example: "Belinda",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return middleName(r), nil
},
})
AddFuncLookup("lastname", Info{
Display: "Last Name",
Category: "person",
Description: "The family name or surname of an individual",
Example: "Daniel",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return lastName(r), nil
},
})
AddFuncLookup("gender", Info{
Display: "Gender",
Category: "person",
Description: "Classification based on social and cultural norms that identifies an individual",
Example: "male",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return gender(r), nil
},
})
AddFuncLookup("ssn", Info{
Display: "SSN",
Category: "person",
Description: "Unique nine-digit identifier used for government and financial purposes in the United States",
Example: "296446360",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return ssn(r), nil
},
})
AddFuncLookup("hobby", Info{
Display: "Hobby",
Category: "person",
Description: "An activity pursued for leisure and pleasure",
Example: "Swimming",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return hobby(r), nil
},
})
AddFuncLookup("email", Info{
Display: "Email",
Category: "person",
Description: "Electronic mail used for sending digital messages and communication over the internet",
Example: "markusmoen@pagac.net",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return email(r), nil
},
})
AddFuncLookup("phone", Info{
Display: "Phone",
Category: "person",
Description: "Numerical sequence used to contact individuals via telephone or mobile devices",
Example: "6136459948",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return phone(r), nil
},
})
AddFuncLookup("phoneformatted", Info{
Display: "Phone Formatted",
Category: "person",
Description: "Formatted phone number of a person",
Example: "136-459-9489",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return phoneFormatted(r), nil
},
})
AddFuncLookup("teams", Info{
Display: "Teams",
Category: "person",
Description: "Randomly split people into teams",
Example: `{
"Team 1": [
"Justin",
"Connor",
"Jeff"
],
"Team 2": [
"Sharon",
"Fabian",
"Billy"
],
"Team 3": [
"Steve",
"Robert"
]
}`,
Output: "map[string][]string",
ContentType: "application/json",
Params: []Param{
{Field: "people", Display: "Strings", Type: "[]string", Description: "Array of people"},
{Field: "teams", Display: "Strings", Type: "[]string", Description: "Array of teams"},
},
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
people, err := info.GetStringArray(m, "people")
if err != nil {
return nil, err
}
teamsArray, err := info.GetStringArray(m, "teams")
if err != nil {
return nil, err
}
return teams(r, people, teamsArray), nil
},
})
}

253
vendor/github.com/brianvoe/gofakeit/v6/product.go generated vendored Normal file
View File

@ -0,0 +1,253 @@
package gofakeit
import (
"fmt"
"math/rand"
"strings"
)
type ProductInfo struct {
Name string `json:"name" xml:"name"`
Description string `json:"description" xml:"description"`
Categories []string `json:"categories" xml:"categories"`
Price float64 `json:"price" xml:"price"`
Features []string `json:"features" xml:"features"`
Color string `json:"color" xml:"color"`
Material string `json:"material" xml:"material"`
UPC string `json:"upc" xml:"upc"`
}
// Product will generate a random set of product information
func Product() *ProductInfo { return product(globalFaker.Rand) }
// Product will generate a random set of product information
func (f *Faker) Product() *ProductInfo { return product(f.Rand) }
func product(r *rand.Rand) *ProductInfo {
// Categories
categories := []string{}
weightedCategory, _ := weighted(r, []any{1, 2, 3, 4}, []float32{1, 4, 3, 4})
for i := 0; i < weightedCategory.(int); i++ {
categories = append(categories, productCategory(r))
}
// Features
features := []string{}
for i := 0; i < number(r, 1, 5); i++ {
features = append(features, productFeature(r))
}
product := &ProductInfo{
Name: productName(r),
Description: productDescription(r),
Categories: categories,
Price: price(r, 3.00, 100.00),
UPC: productUPC(r),
Features: features,
Color: safeColor(r),
Material: productMaterial(r),
}
return product
}
// ProductName will generate a random product name
func ProductName() string { return productName(globalFaker.Rand) }
// ProductName will generate a random product name
func (f *Faker) ProductName() string { return productName(f.Rand) }
func productName(r *rand.Rand) string {
name := getRandValue(r, []string{"product", "name"})
switch number(r, 0, 9) {
case 1:
// Name + Adjective + Feature
return title(fmt.Sprintf("%s %s %s", name, getRandValue(r, []string{"product", "adjective"}), productFeature(r)))
case 2:
// Adjective + Material + Name
return title(fmt.Sprintf("%s %s %s", getRandValue(r, []string{"product", "adjective"}), productMaterial(r), name))
case 3:
// Color + Name + Suffix
return title(fmt.Sprintf("%s %s %s", safeColor(r), name, getRandValue(r, []string{"product", "suffix"})))
case 4:
// Feature + Name + Adjective
return title(fmt.Sprintf("%s %s %s", productFeature(r), name, getRandValue(r, []string{"product", "adjective"})))
case 5:
// Material + Color + Name
return title(fmt.Sprintf("%s %s %s", productMaterial(r), safeColor(r), name))
case 6:
// Name + Suffix + Material
return title(fmt.Sprintf("%s %s %s", name, getRandValue(r, []string{"product", "suffix"}), productMaterial(r)))
case 7:
// Adjective + Feature + Name
return title(fmt.Sprintf("%s %s %s", getRandValue(r, []string{"product", "adjective"}), productFeature(r), name))
case 8:
// Color + Material + Name
return title(fmt.Sprintf("%s %s %s", safeColor(r), productMaterial(r), name))
case 9:
// Suffix + Adjective + Name
return title(fmt.Sprintf("%s %s %s", getRandValue(r, []string{"product", "suffix"}), getRandValue(r, []string{"product", "adjective"}), name))
}
// case: 0 - Adjective + Name + Suffix
return title(fmt.Sprintf("%s %s %s", getRandValue(r, []string{"product", "adjective"}), name, getRandValue(r, []string{"product", "suffix"})))
}
// ProductDescription will generate a random product description
func ProductDescription() string { return productDescription(globalFaker.Rand) }
// ProductDescription will generate a random product description
func (f *Faker) ProductDescription() string { return productDescription(f.Rand) }
func productDescription(r *rand.Rand) string {
desc := []string{}
for i := 0; i < number(r, 1, 3); i++ {
desc = append(desc, sentence(r, number(r, 5, 15)))
}
return strings.Join(desc, " ")
}
// ProductCategory will generate a random product category
func ProductCategory() string { return productCategory(globalFaker.Rand) }
// ProductCategory will generate a random product category
func (f *Faker) ProductCategory() string { return productCategory(f.Rand) }
func productCategory(r *rand.Rand) string {
return getRandValue(r, []string{"product", "category"})
}
// ProductFeature will generate a random product feature
func ProductFeature() string { return productFeature(globalFaker.Rand) }
// ProductFeature will generate a random product feature
func (f *Faker) ProductFeature() string { return productFeature(f.Rand) }
func productFeature(r *rand.Rand) string {
return getRandValue(r, []string{"product", "feature"})
}
// ProductMaterial will generate a random product material
func ProductMaterial() string { return productMaterial(globalFaker.Rand) }
// ProductMaterial will generate a random product material
func (f *Faker) ProductMaterial() string { return productMaterial(f.Rand) }
func productMaterial(r *rand.Rand) string {
return getRandValue(r, []string{"product", "material"})
}
// ProductUPC will generate a random product UPC
func ProductUPC() string { return productUPC(globalFaker.Rand) }
// ProductUPC will generate a random product UPC
func (f *Faker) ProductUPC() string { return productUPC(f.Rand) }
func productUPC(r *rand.Rand) string {
// The first digit of a UPC is a fixed digit (usually 0)
upc := "0"
// Generate the remaining 11 digits randomly
for i := 1; i < 12; i++ {
digit := number(r, 0, 9)
upc += fmt.Sprintf("%d", digit)
}
return upc
}
func addProductLookup() {
AddFuncLookup("product", Info{
Display: "Product",
Category: "product",
Description: "An item created for sale or use",
Example: `{
"name": "olive copper monitor",
"description": "Backwards caused quarterly without week it hungry thing someone him regularly. Whomever this revolt hence from his timing as quantity us these yours.",
"categories": [
"clothing",
"tools and hardware"
],
"price": 7.61,
"features": [
"ultra-lightweight"
],
"color": "navy",
"material": "brass",
"upc": "012780949980"
}`,
Output: "map[string]any",
ContentType: "application/json",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return product(r), nil
},
})
AddFuncLookup("productname", Info{
Display: "Product Name",
Category: "product",
Description: "Distinctive title or label assigned to a product for identification and marketing",
Example: "olive copper monitor",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return productName(r), nil
},
})
AddFuncLookup("productdescription", Info{
Display: "Product Description",
Category: "product",
Description: "Explanation detailing the features and characteristics of a product",
Example: "Backwards caused quarterly without week it hungry thing someone him regularly. Whomever this revolt hence from his timing as quantity us these yours.",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return productDescription(r), nil
},
})
AddFuncLookup("productcategory", Info{
Display: "Product Category",
Category: "product",
Description: "Classification grouping similar products based on shared characteristics or functions",
Example: "clothing",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return productCategory(r), nil
},
})
AddFuncLookup("productfeature", Info{
Display: "Product Feature",
Category: "product",
Description: "Specific characteristic of a product that distinguishes it from others products",
Example: "ultra-lightweight",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return productFeature(r), nil
},
})
AddFuncLookup("productmaterial", Info{
Display: "Product Material",
Category: "product",
Description: "The substance from which a product is made, influencing its appearance, durability, and properties",
Example: "brass",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return productMaterial(r), nil
},
})
AddFuncLookup("productupc", Info{
Display: "Product UPC",
Category: "product",
Description: "Standardized barcode used for product identification and tracking in retail and commerce",
Example: "012780949980",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return productUPC(r), nil
},
})
}

28
vendor/github.com/brianvoe/gofakeit/v6/school.go generated vendored Normal file
View File

@ -0,0 +1,28 @@
package gofakeit
import "math/rand"
// School will generate a random School type
func School() string { return school(globalFaker.Rand) }
func (f *Faker) School() string { return school(f.Rand) }
func school(r *rand.Rand) string {
return getRandValue(
r, []string{"school", "name"}) + " " +
getRandValue(r, []string{"school", "isPrivate"}) + " " +
getRandValue(r, []string{"school", "type"})
}
func addSchoolLookup() {
AddFuncLookup("school", Info{
Display: "School",
Category: "school",
Description: "An institution for formal education and learning",
Example: `Harborview State Academy`,
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return school(r), nil
},
})
}

15
vendor/github.com/brianvoe/gofakeit/v6/slice.go generated vendored Normal file
View File

@ -0,0 +1,15 @@
package gofakeit
import (
"reflect"
)
// Slice fills built-in types and exported fields of a struct with random data.
func Slice(v any) { sliceFunc(globalFaker, v) }
// Slice fills built-in types and exported fields of a struct with random data.
func (f *Faker) Slice(v any) { sliceFunc(f, v) }
func sliceFunc(f *Faker, v any) {
r(f, reflect.TypeOf(v), reflect.ValueOf(v), "", -1)
}

157
vendor/github.com/brianvoe/gofakeit/v6/sql.go generated vendored Normal file
View File

@ -0,0 +1,157 @@
package gofakeit
import (
"encoding/json"
"errors"
"fmt"
"math/rand"
"strings"
)
type SQLOptions struct {
Table string `json:"table" xml:"table"` // Table name we are inserting into
Count int `json:"count" xml:"count"` // How many entries (tuples) we're generating
Fields []Field `json:"fields" xml:"fields"` // The fields to be generated
}
func SQL(so *SQLOptions) (string, error) { return sqlFunc(globalFaker.Rand, so) }
func (f *Faker) SQL(so *SQLOptions) (string, error) { return sqlFunc(f.Rand, so) }
func sqlFunc(r *rand.Rand, so *SQLOptions) (string, error) {
if so.Table == "" {
return "", errors.New("must provide table name to generate SQL")
}
if so.Fields == nil || len(so.Fields) <= 0 {
return "", errors.New(("must pass fields in order to generate SQL queries"))
}
if so.Count <= 0 {
return "", errors.New("must have entry count")
}
var sb strings.Builder
sb.WriteString("INSERT INTO " + so.Table + " ")
// Loop through each field and put together column names
var cols []string
for _, f := range so.Fields {
cols = append(cols, f.Name)
}
sb.WriteString("(" + strings.Join(cols, ", ") + ")")
sb.WriteString(" VALUES ")
for i := 0; i < so.Count; i++ {
// Start opening value
sb.WriteString("(")
// Now, we need to add all of our fields
var endStr string
for ii, field := range so.Fields {
// Set end of value string
endStr = ", "
if ii == len(so.Fields)-1 {
endStr = ""
}
// If autoincrement, add based upon loop
if field.Function == "autoincrement" {
sb.WriteString(fmt.Sprintf("%d%s", i+1, endStr))
continue
}
// Get the function info for the field
funcInfo := GetFuncLookup(field.Function)
if funcInfo == nil {
return "", errors.New("invalid function, " + field.Function + " does not exist")
}
// Generate the value
val, err := funcInfo.Generate(r, &field.Params, funcInfo)
if err != nil {
return "", err
}
// Convert the output value to the proper SQL type
convertType := sqlConvertType(funcInfo.Output, val)
// If its the last field, we need to close the value
sb.WriteString(convertType + endStr)
}
// If its the last value, we need to close the value
if i == so.Count-1 {
sb.WriteString(");")
} else {
sb.WriteString("),")
}
}
return sb.String(), nil
}
// sqlConvertType will take in a type and value and convert it to the proper SQL type
func sqlConvertType(t string, val any) string {
switch t {
case "string":
return `'` + fmt.Sprintf("%v", val) + `'`
case "[]byte":
return `'` + fmt.Sprintf("%s", val) + `'`
default:
return fmt.Sprintf("%v", val)
}
}
func addDatabaseSQLLookup() {
AddFuncLookup("sql", Info{
Display: "SQL",
Category: "database",
Description: "Command in SQL used to add new data records into a database table",
Example: `INSERT INTO people
(id, first_name, price, age, created_at)
VALUES
(1, 'Markus', 804.92, 21, '1937-01-30 07:58:01'),
(2, 'Santino', 235.13, 40, '1964-07-07 22:25:40');`,
Output: "string",
ContentType: "application/sql",
Params: []Param{
{Field: "table", Display: "Table", Type: "string", Description: "Name of the table to insert into"},
{Field: "count", Display: "Count", Type: "int", Default: "100", Description: "Number of inserts to generate"},
{Field: "fields", Display: "Fields", Type: "[]Field", Description: "Fields containing key name and function to run in json format"},
},
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
so := SQLOptions{}
table, err := info.GetString(m, "table")
if err != nil {
return nil, err
}
so.Table = table
count, err := info.GetInt(m, "count")
if err != nil {
return nil, err
}
so.Count = count
fieldsStr, err := info.GetStringArray(m, "fields")
if err != nil {
return nil, err
}
// Check to make sure fields has length
if len(fieldsStr) > 0 {
so.Fields = make([]Field, len(fieldsStr))
for i, f := range fieldsStr {
// Unmarshal fields string into fields array
err = json.Unmarshal([]byte(f), &so.Fields[i])
if err != nil {
return nil, err
}
}
}
return sqlFunc(r, &so)
},
})
}

272
vendor/github.com/brianvoe/gofakeit/v6/string.go generated vendored Normal file
View File

@ -0,0 +1,272 @@
package gofakeit
import "math/rand"
// Letter will generate a single random lower case ASCII letter
func Letter() string { return letter(globalFaker.Rand) }
// Letter will generate a single random lower case ASCII letter
func (f *Faker) Letter() string { return letter(f.Rand) }
func letter(r *rand.Rand) string { return string(randLetter(r)) }
// LetterN will generate a random ASCII string with length N. Note that this function returns a string with a length of 1 when 0 is passed.
func LetterN(n uint) string { return letterN(globalFaker.Rand, n) }
// LetterN will generate a random ASCII string with length N. Note that this function returns a string with a length of 1 when 0 is passed.
func (f *Faker) LetterN(n uint) string { return letterN(f.Rand, n) }
func letterN(r *rand.Rand, n uint) string {
// Make sure we dont use 0
if n == 0 {
n = 1
}
out := make([]rune, n)
for i := 0; i < int(n); i++ {
out[i] = randLetter(r)
}
return string(out)
}
// Vowel will generate a single random lower case vowel
func Vowel() string { return vowel(globalFaker.Rand) }
// Vowel will generate a single random lower case vowel
func (f *Faker) Vowel() string { return vowel(f.Rand) }
func vowel(r *rand.Rand) string { return string(randCharacter(r, vowels)) }
// Digit will generate a single ASCII digit
func Digit() string { return digit(globalFaker.Rand) }
// Digit will generate a single ASCII digit
func (f *Faker) Digit() string { return digit(f.Rand) }
func digit(r *rand.Rand) string { return string(randDigit(r)) }
// DigitN will generate a random string of length N consists of ASCII digits. Note that the string generated can start with 0 and this function returns a string with a length of 1 when 0 is passed.
func DigitN(n uint) string { return digitN(globalFaker.Rand, n) }
// DigitN will generate a random string of length N consists of ASCII digits. Note that the string generated can start with 0 and this function returns a string with a length of 1 when 0 is passed.
func (f *Faker) DigitN(n uint) string { return digitN(f.Rand, n) }
func digitN(r *rand.Rand, n uint) string {
// Make sure we dont use 0
if n == 0 {
n = 1
}
out := make([]rune, n)
for i := 0; i < int(n); i++ {
out[i] = randDigit(r)
}
return string(out)
}
// Numerify will replace # with random numerical values
func Numerify(str string) string { return numerify(globalFaker.Rand, str) }
// Numerify will replace # with random numerical values
func (f *Faker) Numerify(str string) string { return numerify(f.Rand, str) }
func numerify(r *rand.Rand, str string) string { return replaceWithNumbers(r, str) }
// Lexify will replace ? with random generated letters
func Lexify(str string) string { return lexify(globalFaker.Rand, str) }
// Lexify will replace ? with random generated letters
func (f *Faker) Lexify(str string) string { return lexify(f.Rand, str) }
func lexify(r *rand.Rand, str string) string { return replaceWithLetters(r, str) }
// ShuffleStrings will randomize a slice of strings
func ShuffleStrings(a []string) { shuffleStrings(globalFaker.Rand, a) }
// ShuffleStrings will randomize a slice of strings
func (f *Faker) ShuffleStrings(a []string) { shuffleStrings(f.Rand, a) }
func shuffleStrings(r *rand.Rand, a []string) {
swap := func(i, j int) {
a[i], a[j] = a[j], a[i]
}
//to avoid upgrading to 1.10 I copied the algorithm
n := len(a)
if n <= 1 {
return
}
//if size is > int32 probably it will never finish, or ran out of entropy
i := n - 1
for ; i > 0; i-- {
j := int(r.Int31n(int32(i + 1)))
swap(i, j)
}
}
// RandomString will take in a slice of string and return a randomly selected value
func RandomString(a []string) string { return randomString(globalFaker.Rand, a) }
// RandomString will take in a slice of string and return a randomly selected value
func (f *Faker) RandomString(a []string) string { return randomString(f.Rand, a) }
func randomString(r *rand.Rand, a []string) string {
size := len(a)
if size == 0 {
return ""
}
if size == 1 {
return a[0]
}
return a[r.Intn(size)]
}
func addStringLookup() {
AddFuncLookup("letter", Info{
Display: "Letter",
Category: "string",
Description: "Character or symbol from the American Standard Code for Information Interchange (ASCII) character set",
Example: "g",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return letter(r), nil
},
})
AddFuncLookup("lettern", Info{
Display: "LetterN",
Category: "string",
Description: "ASCII string with length N",
Example: "gbRMaRxHki",
Output: "string",
Params: []Param{
{Field: "count", Display: "Count", Type: "uint", Description: "Number of digits to generate"},
},
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
ui, err := info.GetUint(m, "count")
if err != nil {
return nil, err
}
return letterN(r, ui), nil
},
})
AddFuncLookup("vowel", Info{
Display: "Vowel",
Category: "string",
Description: "Speech sound produced with an open vocal tract",
Example: "a",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return vowel(r), nil
},
})
AddFuncLookup("digit", Info{
Display: "Digit",
Category: "string",
Description: "Numerical symbol used to represent numbers",
Example: "0",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return digit(r), nil
},
})
AddFuncLookup("digitn", Info{
Display: "DigitN",
Category: "string",
Description: "string of length N consisting of ASCII digits",
Example: "0136459948",
Output: "string",
Params: []Param{
{Field: "count", Display: "Count", Type: "uint", Description: "Number of digits to generate"},
},
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
ui, err := info.GetUint(m, "count")
if err != nil {
return nil, err
}
return digitN(r, ui), nil
},
})
AddFuncLookup("numerify", Info{
Display: "Numerify",
Category: "string",
Description: "Replace # with random numerical values",
Example: "(###)###-#### => (555)867-5309",
Output: "string",
Params: []Param{
{Field: "str", Display: "String", Type: "string", Description: "String value to replace #'s"},
},
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
str, err := info.GetString(m, "str")
if err != nil {
return nil, err
}
return numerify(r, str), nil
},
})
AddFuncLookup("lexify", Info{
Display: "Lexify",
Category: "string",
Description: "Replace ? with random generated letters",
Example: "?????@??????.com => billy@mister.com",
Output: "string",
Params: []Param{
{Field: "str", Display: "String", Type: "string", Description: "String value to replace ?'s"},
},
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
str, err := info.GetString(m, "str")
if err != nil {
return nil, err
}
return lexify(r, str), nil
},
})
AddFuncLookup("shufflestrings", Info{
Display: "Shuffle Strings",
Category: "string",
Description: "Shuffle an array of strings",
Example: "hello,world,whats,up => whats,world,hello,up",
Output: "[]string",
ContentType: "application/json",
Params: []Param{
{Field: "strs", Display: "Strings", Type: "[]string", Description: "Delimited separated strings"},
},
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
strs, err := info.GetStringArray(m, "strs")
if err != nil {
return nil, err
}
shuffleStrings(r, strs)
return strs, nil
},
})
AddFuncLookup("randomstring", Info{
Display: "Random String",
Category: "string",
Description: "Return a random string from a string array",
Example: "hello,world,whats,up => world",
Output: "[]string",
Params: []Param{
{Field: "strs", Display: "Strings", Type: "[]string", Description: "Delimited separated strings"},
},
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
strs, err := info.GetStringArray(m, "strs")
if err != nil {
return nil, err
}
return randomString(r, strs), nil
},
})
}

583
vendor/github.com/brianvoe/gofakeit/v6/struct.go generated vendored Normal file
View File

@ -0,0 +1,583 @@
package gofakeit
import (
"errors"
"fmt"
"reflect"
"strconv"
"strings"
"time"
)
// Struct fills in exported fields of a struct with random data
// based on the value of `fake` tag of exported fields
// or with the result of a call to the Fake() method
// if the field type implements `Fakeable`.
// Use `fake:"skip"` to explicitly skip an element.
// All built-in types are supported, with templating support
// for string types.
func Struct(v any) error { return structFunc(globalFaker, v) }
// Struct fills in exported fields of a struct with random data
// based on the value of `fake` tag of exported fields.
// Use `fake:"skip"` to explicitly skip an element.
// All built-in types are supported, with templating support
// for string types.
func (f *Faker) Struct(v any) error { return structFunc(f, v) }
func structFunc(f *Faker, v any) error {
return r(f, reflect.TypeOf(v), reflect.ValueOf(v), "", 0)
}
func r(f *Faker, t reflect.Type, v reflect.Value, tag string, size int) error {
// Handle special types
if t.PkgPath() == "encoding/json" {
// encoding/json has two special types:
// - RawMessage
// - Number
switch t.Name() {
case "RawMessage":
return rJsonRawMessage(f, t, v, tag, size)
case "Number":
return rJsonNumber(f, t, v, tag, size)
default:
return errors.New("unknown encoding/json type: " + t.Name())
}
}
// Handle generic types
switch t.Kind() {
case reflect.Ptr:
return rPointer(f, t, v, tag, size)
case reflect.Struct:
return rStruct(f, t, v, tag)
case reflect.String:
return rString(f, t, v, tag)
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
return rUint(f, t, v, tag)
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return rInt(f, t, v, tag)
case reflect.Float32, reflect.Float64:
return rFloat(f, t, v, tag)
case reflect.Bool:
return rBool(f, t, v, tag)
case reflect.Array, reflect.Slice:
return rSlice(f, t, v, tag, size)
case reflect.Map:
return rMap(f, t, v, tag, size)
}
return nil
}
func rCustom(f *Faker, t reflect.Type, v reflect.Value, tag string) error {
// If tag is empty return error
if tag == "" {
return errors.New("tag is empty")
}
fName, fParams := parseNameAndParamsFromTag(tag)
info := GetFuncLookup(fName)
// Check to see if it's a replaceable lookup function
if info == nil {
return fmt.Errorf("function %q not found", tag)
}
// Parse map params
mapParams := parseMapParams(info, fParams)
// Call function
fValue, err := info.Generate(f.Rand, mapParams, info)
if err != nil {
return err
}
// Create new element of expected type
field := reflect.New(reflect.TypeOf(fValue))
field.Elem().Set(reflect.ValueOf(fValue))
// Check if element is pointer if so
// grab the underlying value
fieldElem := field.Elem()
if fieldElem.Kind() == reflect.Ptr {
fieldElem = fieldElem.Elem()
}
// Check if field kind is the same as the expected type
if fieldElem.Kind() != v.Kind() {
// return error saying the field and kinds that do not match
return errors.New("field kind " + fieldElem.Kind().String() + " does not match expected kind " + v.Kind().String())
}
// Set the value
v.Set(fieldElem.Convert(v.Type()))
// If a function is called to set the struct
// stop from going through sub fields
return nil
}
func rStruct(f *Faker, t reflect.Type, v reflect.Value, tag string) error {
// Check if tag exists, if so run custom function
if t.Name() != "" && tag != "" {
return rCustom(f, t, v, tag)
}
// Check if struct is fakeable
if isFakeable(t) {
value, err := callFake(f, v, reflect.Struct)
if err != nil {
return err
}
v.Set(reflect.ValueOf(value))
return nil
}
// Loop through all the fields of the struct
n := t.NumField()
for i := 0; i < n; i++ {
elementT := t.Field(i)
elementV := v.Field(i)
fakeTag, ok := elementT.Tag.Lookup("fake")
// Check whether or not to skip this field
if ok && fakeTag == "skip" || fakeTag == "-" {
// Do nothing, skip it
continue
}
// Check to make sure you can set it or that it's an embedded(anonymous) field
if !elementV.CanSet() && !elementT.Anonymous {
continue
}
// Check if reflect type is of values we can specifically set
elemStr := elementT.Type.String()
switch elemStr {
case "time.Time", "*time.Time":
// Check if element is a pointer
elemV := elementV
if elemStr == "*time.Time" {
elemV = reflect.New(elementT.Type.Elem()).Elem()
}
// Run rTime on the element
err := rTime(f, elementT, elemV, fakeTag)
if err != nil {
return err
}
if elemStr == "*time.Time" {
elementV.Set(elemV.Addr())
}
continue
}
// Check if fakesize is set
size := -1 // Set to -1 to indicate fakesize was not set
fs, ok := elementT.Tag.Lookup("fakesize")
if ok {
var err error
// Check if size has params separated by ,
if strings.Contains(fs, ",") {
sizeSplit := strings.SplitN(fs, ",", 2)
if len(sizeSplit) == 2 {
var sizeMin int
var sizeMax int
sizeMin, err = strconv.Atoi(sizeSplit[0])
if err != nil {
return err
}
sizeMax, err = strconv.Atoi(sizeSplit[1])
if err != nil {
return err
}
size = f.Rand.Intn(sizeMax-sizeMin+1) + sizeMin
}
} else {
size, err = strconv.Atoi(fs)
if err != nil {
return err
}
}
}
// Recursively call r() to fill in the struct
err := r(f, elementT.Type, elementV, fakeTag, size)
if err != nil {
return err
}
}
return nil
}
func rPointer(f *Faker, t reflect.Type, v reflect.Value, tag string, size int) error {
elemT := t.Elem()
if v.IsNil() {
nv := reflect.New(elemT).Elem()
err := r(f, elemT, nv, tag, size)
if err != nil {
return err
}
v.Set(nv.Addr())
} else {
err := r(f, elemT, v.Elem(), tag, size)
if err != nil {
return err
}
}
return nil
}
func rSlice(f *Faker, t reflect.Type, v reflect.Value, tag string, size int) error {
// If you cant even set it dont even try
if !v.CanSet() {
return errors.New("cannot set slice")
}
// Check if tag exists, if so run custom function
if t.Name() != "" && tag != "" {
// Check to see if custom function works if not continue to normal loop of values
err := rCustom(f, t, v, tag)
if err == nil {
return nil
}
} else if isFakeable(t) {
value, err := callFake(f, v, reflect.Slice)
if err != nil {
return err
}
v.Set(reflect.ValueOf(value))
return nil
}
// Grab original size to use if needed for sub arrays
ogSize := size
// If the value has a len and is less than the size
// use that instead of the requested size
elemLen := v.Len()
if elemLen == 0 && size == -1 {
size = number(f.Rand, 1, 10)
} else if elemLen != 0 && (size == -1 || elemLen < size) {
size = elemLen
}
// Get the element type
elemT := t.Elem()
// Loop through the elements length and set based upon the index
for i := 0; i < size; i++ {
nv := reflect.New(elemT)
err := r(f, elemT, nv.Elem(), tag, ogSize)
if err != nil {
return err
}
// If values are already set fill them up, otherwise append
if elemLen != 0 {
v.Index(i).Set(reflect.Indirect(nv))
} else {
v.Set(reflect.Append(reflect.Indirect(v), reflect.Indirect(nv)))
}
}
return nil
}
func rMap(f *Faker, t reflect.Type, v reflect.Value, tag string, size int) error {
// If you cant even set it dont even try
if !v.CanSet() {
return errors.New("cannot set slice")
}
// Check if tag exists, if so run custom function
if tag != "" {
return rCustom(f, t, v, tag)
} else if size > 0 {
// NOOP
} else if isFakeable(t) {
value, err := callFake(f, v, reflect.Map)
if err != nil {
return err
}
v.Set(reflect.ValueOf(value))
return nil
}
// Set a size
newSize := size
if newSize == -1 {
newSize = number(f.Rand, 1, 10)
}
// Create new map based upon map key value type
mapType := reflect.MapOf(t.Key(), t.Elem())
newMap := reflect.MakeMap(mapType)
for i := 0; i < newSize; i++ {
// Create new key
mapIndex := reflect.New(t.Key())
err := r(f, t.Key(), mapIndex.Elem(), "", -1)
if err != nil {
return err
}
// Create new value
mapValue := reflect.New(t.Elem())
err = r(f, t.Elem(), mapValue.Elem(), "", -1)
if err != nil {
return err
}
newMap.SetMapIndex(mapIndex.Elem(), mapValue.Elem())
}
// Set newMap into struct field
if t.Kind() == reflect.Ptr {
v.Set(newMap.Elem())
} else {
v.Set(newMap)
}
return nil
}
func rString(f *Faker, t reflect.Type, v reflect.Value, tag string) error {
if tag != "" {
v.SetString(generate(f.Rand, tag))
} else if isFakeable(t) {
value, err := callFake(f, v, reflect.String)
if err != nil {
return err
}
valueStr, ok := value.(string)
if !ok {
return errors.New("call to Fake method did not return a string")
}
v.SetString(valueStr)
} else {
v.SetString(generate(f.Rand, strings.Repeat("?", number(f.Rand, 4, 10))))
}
return nil
}
func rInt(f *Faker, t reflect.Type, v reflect.Value, tag string) error {
if tag != "" {
i, err := strconv.ParseInt(generate(f.Rand, tag), 10, 64)
if err != nil {
return err
}
v.SetInt(i)
} else if isFakeable(t) {
value, err := callFake(f, v, reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64)
if err != nil {
return err
}
switch i := value.(type) {
case int:
v.SetInt(int64(i))
case int8:
v.SetInt(int64(i))
case int16:
v.SetInt(int64(i))
case int32:
v.SetInt(int64(i))
case int64:
v.SetInt(int64(i))
default:
return errors.New("call to Fake method did not return an integer")
}
} else {
// If no tag or error converting to int, set with random value
switch t.Kind() {
case reflect.Int:
v.SetInt(int64Func(f.Rand))
case reflect.Int8:
v.SetInt(int64(int8Func(f.Rand)))
case reflect.Int16:
v.SetInt(int64(int16Func(f.Rand)))
case reflect.Int32:
v.SetInt(int64(int32Func(f.Rand)))
case reflect.Int64:
v.SetInt(int64Func(f.Rand))
}
}
return nil
}
func rUint(f *Faker, t reflect.Type, v reflect.Value, tag string) error {
if tag != "" {
u, err := strconv.ParseUint(generate(f.Rand, tag), 10, 64)
if err != nil {
return err
}
v.SetUint(u)
} else if isFakeable(t) {
value, err := callFake(f, v, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64)
if err != nil {
return err
}
switch i := value.(type) {
case uint:
v.SetUint(uint64(i))
case uint8:
v.SetUint(uint64(i))
case uint16:
v.SetUint(uint64(i))
case uint32:
v.SetUint(uint64(i))
case uint64:
v.SetUint(uint64(i))
default:
return errors.New("call to Fake method did not return an unsigned integer")
}
} else {
// If no tag or error converting to uint, set with random value
switch t.Kind() {
case reflect.Uint:
v.SetUint(uint64Func(f.Rand))
case reflect.Uint8:
v.SetUint(uint64(uint8Func(f.Rand)))
case reflect.Uint16:
v.SetUint(uint64(uint16Func(f.Rand)))
case reflect.Uint32:
v.SetUint(uint64(uint32Func(f.Rand)))
case reflect.Uint64:
v.SetUint(uint64Func(f.Rand))
}
}
return nil
}
func rFloat(f *Faker, t reflect.Type, v reflect.Value, tag string) error {
if tag != "" {
f, err := strconv.ParseFloat(generate(f.Rand, tag), 64)
if err != nil {
return err
}
v.SetFloat(f)
} else if isFakeable(t) {
value, err := callFake(f, v, reflect.Float32, reflect.Float64)
if err != nil {
return err
}
switch i := value.(type) {
case float32:
v.SetFloat(float64(i))
case float64:
v.SetFloat(float64(i))
default:
return errors.New("call to Fake method did not return a float")
}
} else {
// If no tag or error converting to float, set with random value
switch t.Kind() {
case reflect.Float64:
v.SetFloat(float64Func(f.Rand))
case reflect.Float32:
v.SetFloat(float64(float32Func(f.Rand)))
}
}
return nil
}
func rBool(f *Faker, t reflect.Type, v reflect.Value, tag string) error {
if tag != "" {
b, err := strconv.ParseBool(generate(f.Rand, tag))
if err != nil {
return err
}
v.SetBool(b)
} else if isFakeable(t) {
value, err := callFake(f, v, reflect.Bool)
if err != nil {
return err
}
switch i := value.(type) {
case bool:
v.SetBool(bool(i))
default:
return errors.New("call to Fake method did not return a boolean")
}
} else {
// If no tag or error converting to boolean, set with random value
v.SetBool(boolFunc(f.Rand))
}
return nil
}
// rTime will set a time.Time field the best it can from either the default date tag or from the generate tag
func rTime(f *Faker, t reflect.StructField, v reflect.Value, tag string) error {
if tag != "" {
// Generate time
timeOutput := generate(f.Rand, tag)
// Check to see if timeOutput has monotonic clock reading
// if so, remove it. This is because time.Parse() does not
// support parsing the monotonic clock reading
if strings.Contains(timeOutput, " m=") {
timeOutput = strings.Split(timeOutput, " m=")[0]
}
// Check to see if they are passing in a format to parse the time
timeFormat, timeFormatOK := t.Tag.Lookup("format")
if timeFormatOK {
timeFormat = javaDateFormatToGolangDateFormat(timeFormat)
} else {
// If tag == "{date}" use time.RFC3339
// They are attempting to use the default date lookup
if tag == "{date}" {
timeFormat = time.RFC3339
} else {
// Default format of time.Now().String()
timeFormat = "2006-01-02 15:04:05.999999999 -0700 MST"
}
}
// If output is larger than format cut the output
// This helps us avoid errors from time.Parse
if len(timeOutput) > len(timeFormat) {
timeOutput = timeOutput[:len(timeFormat)]
}
// Attempt to parse the time
timeStruct, err := time.Parse(timeFormat, timeOutput)
if err != nil {
return err
}
v.Set(reflect.ValueOf(timeStruct))
return nil
}
v.Set(reflect.ValueOf(date(f.Rand)))
return nil
}

443
vendor/github.com/brianvoe/gofakeit/v6/template.go generated vendored Normal file
View File

@ -0,0 +1,443 @@
package gofakeit
import (
"bytes"
"fmt"
"math/rand"
"reflect"
"strconv"
"strings"
"text/template"
"time"
)
// TemplateOptions defines values needed for template document generation
type TemplateOptions struct {
Funcs template.FuncMap `fake:"-"`
Data any `json:"data" xml:"data" fake:"-"`
}
// Template generates an document based on the the supplied template
func Template(template string, co *TemplateOptions) (string, error) {
if co == nil {
co = &TemplateOptions{}
globalFaker.Struct(co)
}
return templateFunc(template, templateFuncMap(globalFaker.Rand, &co.Funcs), co)
}
// Template generates an document based on the the supplied template
func (f *Faker) Template(template string, co *TemplateOptions) (string, error) {
if co == nil {
co = &TemplateOptions{}
f.Struct(co)
}
return templateFunc(template, templateFuncMap(f.Rand, &co.Funcs), co)
}
// MarkdownOptions defines values needed for markdown document generation
type MarkdownOptions struct {
}
// Template for Markdown
const templateMarkdown = `
{{$repo := Gamertag}}
{{$language := RandomString (SliceString "go" "python" "javascript")}}
{{$username := Gamertag}}
{{$weightedSlice := SliceAny "github.com" "gitlab.com" "bitbucket.org"}}
{{$weightedWeights := SliceF32 5 1 1}}
{{$domain := Weighted $weightedSlice $weightedWeights}}
{{$action := RandomString (SliceString "process" "run" "execute" "perform" "handle")}}
{{$usage := RandomString (SliceString "whimsical story" "quirky message" "playful alert" "funny request" "lighthearted command")}}
{{$result := RandomString (SliceString "success" "error" "unknown" "completed" "failed" "finished" "in progress" "terminated")}}
# {{$repo}}
*Author: {{FirstName}} {{LastName}}*
{{Paragraph 2 5 7 "\n\n"}}
## Table of Contents
- [Installation](#installation)
- [Usage](#usage)
- [License](#license)
## Installation
{{if eq $language "go"}}'''go
go get {{$domain}}/{{$username}}/{{$repo}}
'''{{else if eq $language "python"}}'''bash
pip install {{$repo}}
'''{{else if eq $language "javascript"}}'''js
npm install {{$repo}}
'''{{end}}
## Usage
{{if eq $language "go"}}'''go
result := {{$repo}}.{{$action}}("{{ToLower $usage}}")
fmt.Println("{{ToLower $repo}} result:", "{{ToLower $result}}")
'''{{else if eq $language "python"}}'''python
result = {{ToLower $repo}}.{{$action}}("{{ToLower $usage}}")
print("{{ToLower $repo}} result:", "{{ToLower $result}}")
'''{{else if eq $language "javascript"}}'''javascript
const result = {{ToLower $repo}}.{{$action}}("{{ToLower $usage}}");
console.log("{{ToLower $repo}} result:", "{{ToLower $result}}");
'''{{end}}
## License
{{RandomString (SliceString "MIT" "Apache 2.0" "GPL-3.0" "BSD-3-Clause" "ISC")}}
`
// Markdown will return a single random Markdown template document
func Markdown(co *MarkdownOptions) (string, error) {
if co == nil {
co = &MarkdownOptions{}
globalFaker.Struct(co)
}
return templateFunc(templateMarkdown, templateFuncMap(globalFaker.Rand, nil), co)
}
// Markdown will return a single random Markdown template document
func (f *Faker) Markdown(co *MarkdownOptions) (string, error) {
if co == nil {
co = &MarkdownOptions{}
f.Struct(co)
}
return templateFunc(templateMarkdown, templateFuncMap(f.Rand, nil), co)
}
// EmailOptions defines values needed for email document generation
type EmailOptions struct {
}
// Template for email text
const templateEmail = `
Subject: {{RandomString (SliceString "Greetings" "Hello" "Hi")}} from {{FirstName}}!
Dear {{LastName}},
{{RandomString (SliceString "Greetings!" "Hello there!" "Hi, how are you?")}} {{RandomString (SliceString "How's everything going?" "I hope your day is going well." "Sending positive vibes your way.")}}
{{RandomString (SliceString "I trust this email finds you well." "I hope you're doing great." "Hoping this message reaches you in good spirits.")}} {{RandomString (SliceString "Wishing you a fantastic day!" "May your week be filled with joy." "Sending good vibes your way.")}}
{{Paragraph 3 5 10 "\n\n"}}
{{RandomString (SliceString "I would appreciate your thoughts on" "I'm eager to hear your feedback on" "I'm curious to know what you think about")}} it. If you have a moment, please feel free to check out the project on {{RandomString (SliceString "GitHub" "GitLab" "Bitbucket")}}
{{RandomString (SliceString "Your insights would be invaluable." "I'm eager to hear what you think." "Feel free to share your opinions with me.")}} {{RandomString (SliceString "Looking forward to your feedback!" "Your perspective is highly valued." "Your thoughts matter to me.")}}
{{RandomString (SliceString "Thank you for your consideration!" "I appreciate your attention to this matter." "Your support means a lot to me.")}} {{RandomString (SliceString "Wishing you a wonderful day!" "Thanks in advance for your time." "Your feedback is greatly appreciated.")}}
{{RandomString (SliceString "Warm regards" "Best wishes" "Kind regards" "Sincerely" "With gratitude")}}
{{FirstName}} {{LastName}}
{{Email}}
{{PhoneFormatted}}
`
// EmailText will return a single random text email template document
func EmailText(co *EmailOptions) (string, error) {
if co == nil {
co = &EmailOptions{}
globalFaker.Struct(co)
}
return templateFunc(templateEmail, templateFuncMap(globalFaker.Rand, nil), co)
}
// EmailText will return a single random text email template document
func (f *Faker) EmailText(co *EmailOptions) (string, error) {
if co == nil {
co = &EmailOptions{}
f.Struct(co)
}
return templateFunc(templateEmail, templateFuncMap(f.Rand, nil), co)
}
// functions that wont work with template engine
var templateExclusion = []string{
"RandomMapKey",
"SQL",
"Template",
}
// Build the template.FuncMap for the template engine
func templateFuncMap(r *rand.Rand, fm *template.FuncMap) *template.FuncMap {
// create a new function map
funcMap := template.FuncMap{}
// build the function map from a faker using their rand
f := &Faker{Rand: r}
v := reflect.ValueOf(f)
// loop through the methods
for i := 0; i < v.NumMethod(); i++ {
// check if the method is in the exclusion list
if stringInSlice(v.Type().Method(i).Name, templateExclusion) {
continue
}
// Check if method has return values
// If not don't add to function map
if v.Type().Method(i).Type.NumOut() == 0 {
continue
}
// add the method to the function map
funcMap[v.Type().Method(i).Name] = v.Method(i).Interface()
}
// make string upper case
funcMap["ToUpper"] = strings.ToUpper
// make string lower case
funcMap["ToLower"] = strings.ToLower
// make string title case
funcMap["IntRange"] = func(start, end int) []int {
n := end - start + 1
result := make([]int, n)
for i := 0; i < n; i++ {
result[i] = start + i
}
return result
}
// enable passing any type to return a string
funcMap["ToInt"] = func(args any) int {
switch v := args.(type) {
case string:
i, err := strconv.Atoi(v)
if err != nil {
return 0
}
return i
case float64:
return int(v)
case float32:
return int(v)
case int:
return v
// Anything else return 0
default:
return 0
}
}
// enable passing any type to return a float64
funcMap["ToFloat"] = func(args any) float64 {
switch v := args.(type) {
case string:
i, err := strconv.ParseFloat(v, 64)
if err != nil {
return 0
}
return i
case float64:
return v
case float32:
return float64(v)
case int:
return float64(v)
// Anything else return 0
default:
return 0
}
}
// ensable passing any type to return a string
funcMap["ToString"] = func(args any) string {
switch v := args.(type) {
case string:
return v
case float64:
return strconv.FormatFloat(v, 'f', -1, 64)
case float32:
return strconv.FormatFloat(float64(v), 'f', -1, 32)
case int:
return strconv.Itoa(v)
// Anything else return empty string
default:
return ""
}
}
// function to convert string to date time
funcMap["ToDate"] = func(dateString string) time.Time {
date, err := time.Parse("2006-01-02", dateString)
if err != nil {
return time.Now()
}
return date
}
// enable passing slice of interface to functions
funcMap["SliceAny"] = func(args ...any) []any {
return args
}
// enable passing slice of string to functions
funcMap["SliceString"] = func(args ...string) []string {
return args
}
// enable passing slice of uint to functions
funcMap["SliceUInt"] = func(args ...uint) []uint {
return args
}
// enable passing slice of int to functions
funcMap["SliceInt"] = func(args ...int) []int {
return args
}
// enable passing slice of int to functions
funcMap["SliceF32"] = func(args ...float32) []float32 {
return args
}
// Add passed in function map to the function map
if fm != nil {
for k, v := range *fm {
funcMap[k] = v
}
}
return &funcMap
}
// function to build the function map for the template engine from the global faker
func templateFunc(temp string, funcs *template.FuncMap, data any) (string, error) {
if temp == "" {
return "", fmt.Errorf("template parameter is empty")
}
// Create a new template and parse
template_gen, err := template.New("CodeRun").Funcs(*funcs).Parse(temp)
if err != nil {
return "", err
}
b := &bytes.Buffer{}
err = template_gen.Execute(b, data)
if err != nil {
return "", err
}
// Return the result
return strings.ReplaceAll(b.String(), "\\n", "\n"), nil
}
// addTemplateLookup will add the template functions to the global lookup
func addTemplateLookup() {
AddFuncLookup("template", Info{
Display: "Template",
Category: "template",
Description: "Generates document from template",
Example: `{{Firstname}} {{Lastname}}
// output
Markus Moen`,
Output: "string",
ContentType: "text/plain",
Params: []Param{
{Field: "template", Display: "Template", Type: "string", Description: "Golang template to generate the document from"},
{Field: "data", Display: "Custom Data", Type: "string", Default: "", Optional: true, Description: "Custom data to pass to the template"},
},
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
tpl, err := info.GetString(m, "template")
if err != nil {
return nil, err
}
data, err := info.GetAny(m, "data")
if err != nil {
return nil, err
}
templateOut, err := templateFunc(tpl, templateFuncMap(r, nil), &TemplateOptions{Data: data})
if err != nil {
return nil, err
}
return templateOut, nil
},
})
AddFuncLookup("markdown", Info{
Display: "Random markdown document",
Category: "template",
Description: "Lightweight markup language used for formatting plain text",
Example: `# PurpleSheep5
*Author: Amie Feil*
Quarterly without week it hungry thing someone. Him regularly today whomever this revolt hence. From his timing as quantity us these. Yours live these frantic not may another. How this ours his them those whose.
Them batch its Iraqi most that few. Abroad cheese this whereas next how there. Gorgeous genetics time choir fiction therefore yourselves. Am those infrequently heap software quarterly rather. Punctuation yellow where several his orchard to.
## Table of Contents
- [Installation](#installation)
- [Usage](#usage)
- [License](#license)
## Installation
'''bash
pip install PurpleSheep5
'''
## Usage
'''python
result = purplesheep5.process("funny request")
print("purplesheep5 result:", "in progress")
'''
## License
MIT`,
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
template_result, err := templateFunc(templateMarkdown, templateFuncMap(r, nil), &MarkdownOptions{})
return string(template_result), err
},
})
AddFuncLookup("email_text", Info{
Display: "Random text email Document",
Category: "template",
Description: "Written content of an email message, including the sender's message to the recipient",
Example: `Subject: Greetings from Marcel!
Dear Pagac,
Hello there! Sending positive vibes your way.
I hope you're doing great. May your week be filled with joy.
Virtually woman where team late quarterly without week it hungry. Thing someone him regularly today whomever this revolt hence from. His timing as quantity us these yours live these frantic. Not may another how this ours his them those whose. Them batch its Iraqi most that few abroad cheese this.
Whereas next how there gorgeous genetics time choir fiction therefore. Yourselves am those infrequently heap software quarterly rather punctuation yellow. Where several his orchard to frequently hence victorious boxers each. Does auspicious yourselves first soup tomorrow this that must conclude. Anyway some yearly who cough laugh himself both yet rarely.
Me dolphin intensely block would leap plane us first then. Down them eager would hundred super throughout animal yet themselves. Been group flock shake part purchase up usually it her. None it hers boat what their there Turkmen moreover one. Lebanese to brace these shower in it everybody should whatever.
I'm curious to know what you think about it. If you have a moment, please feel free to check out the project on Bitbucket
I'm eager to hear what you think. Looking forward to your feedback!
Thank you for your consideration! Thanks in advance for your time.
Kind regards
Milford Johnston
jamelhaag@king.org
(507)096-3058`,
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
template_result, err := templateFunc(templateEmail, templateFuncMap(r, nil), &EmailOptions{})
return string(template_result), err
},
})
}

500
vendor/github.com/brianvoe/gofakeit/v6/time.go generated vendored Normal file
View File

@ -0,0 +1,500 @@
package gofakeit
import (
"math/rand"
"strconv"
"strings"
"time"
)
// Date will generate a random time.Time struct
func Date() time.Time { return date(globalFaker.Rand) }
// Date will generate a random time.Time struct
func (f *Faker) Date() time.Time { return date(f.Rand) }
func date(r *rand.Rand) time.Time {
return time.Date(year(r), time.Month(month(r)), day(r), hour(r), minute(r), second(r), nanoSecond(r), time.UTC)
}
// FutureDate will generate a random past time.Time struct
func PastDate() time.Time { return pastDate(globalFaker.Rand) }
// FutureDate will generate a random past time.Time struct
func (f *Faker) PastDate() time.Time { return pastDate(f.Rand) }
func pastDate(r *rand.Rand) time.Time {
return time.Now().Add(time.Hour * -time.Duration(number(r, 1, 12)))
}
// FutureDate will generate a random future time.Time struct
func FutureDate() time.Time { return futureDate(globalFaker.Rand) }
// FutureDate will generate a random future time.Time struct
func (f *Faker) FutureDate() time.Time { return futureDate(f.Rand) }
func futureDate(r *rand.Rand) time.Time {
return time.Now().Add(time.Hour * time.Duration(number(r, 1, 12)))
}
// DateRange will generate a random time.Time struct between a start and end date
func DateRange(start, end time.Time) time.Time { return dateRange(globalFaker.Rand, start, end) }
// DateRange will generate a random time.Time struct between a start and end date
func (f *Faker) DateRange(start, end time.Time) time.Time { return dateRange(f.Rand, start, end) }
func dateRange(r *rand.Rand, start time.Time, end time.Time) time.Time {
return time.Unix(0, int64(number(r, int(start.UnixNano()), int(end.UnixNano())))).UTC()
}
// NanoSecond will generate a random nano second
func NanoSecond() int { return nanoSecond(globalFaker.Rand) }
// NanoSecond will generate a random nano second
func (f *Faker) NanoSecond() int { return nanoSecond(f.Rand) }
func nanoSecond(r *rand.Rand) int { return number(r, 0, 999999999) }
// Second will generate a random second
func Second() int { return second(globalFaker.Rand) }
// Second will generate a random second
func (f *Faker) Second() int { return second(f.Rand) }
func second(r *rand.Rand) int { return number(r, 0, 59) }
// Minute will generate a random minute
func Minute() int { return minute(globalFaker.Rand) }
// Minute will generate a random minute
func (f *Faker) Minute() int { return minute(f.Rand) }
func minute(r *rand.Rand) int { return number(r, 0, 59) }
// Hour will generate a random hour - in military time
func Hour() int { return hour(globalFaker.Rand) }
// Hour will generate a random hour - in military time
func (f *Faker) Hour() int { return hour(f.Rand) }
func hour(r *rand.Rand) int { return number(r, 0, 23) }
// Day will generate a random day between 1 - 31
func Day() int { return day(globalFaker.Rand) }
// Day will generate a random day between 1 - 31
func (f *Faker) Day() int { return day(f.Rand) }
func day(r *rand.Rand) int { return number(r, 1, 31) }
// WeekDay will generate a random weekday string (Monday-Sunday)
func WeekDay() string { return weekDay(globalFaker.Rand) }
// WeekDay will generate a random weekday string (Monday-Sunday)
func (f *Faker) WeekDay() string { return weekDay(f.Rand) }
func weekDay(r *rand.Rand) string { return time.Weekday(number(r, 0, 6)).String() }
// Month will generate a random month int
func Month() int { return month(globalFaker.Rand) }
// Month will generate a random month int
func (f *Faker) Month() int { return month(f.Rand) }
func month(r *rand.Rand) int { return number(r, 1, 12) }
// MonthString will generate a random month string
func MonthString() string { return monthString(globalFaker.Rand) }
// MonthString will generate a random month string
func (f *Faker) MonthString() string { return monthString(f.Rand) }
func monthString(r *rand.Rand) string { return time.Month(number(r, 1, 12)).String() }
// Year will generate a random year between 1900 - current year
func Year() int { return year(globalFaker.Rand) }
// Year will generate a random year between 1900 - current year
func (f *Faker) Year() int { return year(f.Rand) }
func year(r *rand.Rand) int { return number(r, 1900, time.Now().Year()) }
// TimeZone will select a random timezone string
func TimeZone() string { return timeZone(globalFaker.Rand) }
// TimeZone will select a random timezone string
func (f *Faker) TimeZone() string { return timeZone(f.Rand) }
func timeZone(r *rand.Rand) string { return getRandValue(r, []string{"timezone", "text"}) }
// TimeZoneFull will select a random full timezone string
func TimeZoneFull() string { return timeZoneFull(globalFaker.Rand) }
// TimeZoneFull will select a random full timezone string
func (f *Faker) TimeZoneFull() string { return timeZoneFull(f.Rand) }
func timeZoneFull(r *rand.Rand) string { return getRandValue(r, []string{"timezone", "full"}) }
// TimeZoneRegion will select a random region style timezone string, e.g. "America/Chicago"
func TimeZoneRegion() string { return timeZoneRegion(globalFaker.Rand) }
// TimeZoneRegion will select a random region style timezone string, e.g. "America/Chicago"
func (f *Faker) TimeZoneRegion() string { return timeZoneRegion(f.Rand) }
func timeZoneRegion(r *rand.Rand) string { return getRandValue(r, []string{"timezone", "region"}) }
// TimeZoneAbv will select a random timezone abbreviation string
func TimeZoneAbv() string { return timeZoneAbv(globalFaker.Rand) }
// TimeZoneAbv will select a random timezone abbreviation string
func (f *Faker) TimeZoneAbv() string { return timeZoneAbv(f.Rand) }
func timeZoneAbv(r *rand.Rand) string { return getRandValue(r, []string{"timezone", "abr"}) }
// TimeZoneOffset will select a random timezone offset
func TimeZoneOffset() float32 { return timeZoneOffset(globalFaker.Rand) }
// TimeZoneOffset will select a random timezone offset
func (f *Faker) TimeZoneOffset() float32 { return timeZoneOffset(f.Rand) }
func timeZoneOffset(r *rand.Rand) float32 {
value, _ := strconv.ParseFloat(getRandValue(r, []string{"timezone", "offset"}), 32)
return float32(value)
}
// javaDateFormatToGolangDateFormat converts java date format into go date format
func javaDateFormatToGolangDateFormat(format string) string {
format = strings.Replace(format, "ddd", "_2", -1)
format = strings.Replace(format, "dd", "02", -1)
format = strings.Replace(format, "d", "2", -1)
format = strings.Replace(format, "HH", "15", -1)
format = strings.Replace(format, "hh", "03", -1)
format = strings.Replace(format, "h", "3", -1)
format = strings.Replace(format, "mm", "04", -1)
format = strings.Replace(format, "m", "4", -1)
format = strings.Replace(format, "ss", "05", -1)
format = strings.Replace(format, "s", "5", -1)
format = strings.Replace(format, "yyyy", "2006", -1)
format = strings.Replace(format, "yy", "06", -1)
format = strings.Replace(format, "y", "06", -1)
format = strings.Replace(format, "SSS", "000", -1)
format = strings.Replace(format, "a", "pm", -1)
format = strings.Replace(format, "aa", "PM", -1)
format = strings.Replace(format, "MMMM", "January", -1)
format = strings.Replace(format, "MMM", "Jan", -1)
format = strings.Replace(format, "MM", "01", -1)
format = strings.Replace(format, "M", "1", -1)
format = strings.Replace(format, "ZZ", "-0700", -1)
if !strings.Contains(format, "Z07") {
format = strings.Replace(format, "Z", "-07", -1)
}
format = strings.Replace(format, "zz:zz", "Z07:00", -1)
format = strings.Replace(format, "zzzz", "Z0700", -1)
format = strings.Replace(format, "z", "MST", -1)
format = strings.Replace(format, "EEEE", "Monday", -1)
format = strings.Replace(format, "E", "Mon", -1)
return format
}
func addDateTimeLookup() {
AddFuncLookup("date", Info{
Display: "Date",
Category: "time",
Description: "Representation of a specific day, month, and year, often used for chronological reference",
Example: "2006-01-02T15:04:05Z07:00",
Output: "string",
Params: []Param{
{
Field: "format",
Display: "Format",
Type: "string",
Default: "RFC3339",
Options: []string{"ANSIC", "UnixDate", "RubyDate", "RFC822", "RFC822Z", "RFC850", "RFC1123", "RFC1123Z", "RFC3339", "RFC3339Nano"},
Description: "Date time string format output. You may also use golang time format or java time format",
},
},
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
format, err := info.GetString(m, "format")
if err != nil {
return nil, err
}
switch format {
case "ANSIC":
return Date().Format(time.ANSIC), nil
case "UnixDate":
return Date().Format(time.UnixDate), nil
case "RubyDate":
return Date().Format(time.RubyDate), nil
case "RFC822":
return Date().Format(time.RFC822), nil
case "RFC822Z":
return Date().Format(time.RFC822Z), nil
case "RFC850":
return Date().Format(time.RFC850), nil
case "RFC1123":
return Date().Format(time.RFC1123), nil
case "RFC1123Z":
return Date().Format(time.RFC1123Z), nil
case "RFC3339":
return Date().Format(time.RFC3339), nil
case "RFC3339Nano":
return Date().Format(time.RFC3339Nano), nil
default:
if format == "" {
return Date().Format(time.RFC3339), nil
}
return Date().Format(javaDateFormatToGolangDateFormat(format)), nil
}
},
})
AddFuncLookup("daterange", Info{
Display: "DateRange",
Category: "time",
Description: "Random date between two ranges",
Example: "2006-01-02T15:04:05Z07:00",
Output: "string",
Params: []Param{
{
Field: "startdate",
Display: "Start Date",
Type: "string",
Default: "1970-01-01",
Description: "Start date time string",
},
{
Field: "enddate",
Display: "End Date",
Type: "string",
Default: time.Now().Format("2006-01-02"),
Description: "End date time string",
},
{
Field: "format",
Display: "Format",
Type: "string",
Default: "yyyy-MM-dd",
Description: "Date time string format",
},
},
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
format, err := info.GetString(m, "format")
if err != nil {
return nil, err
}
format = javaDateFormatToGolangDateFormat(format)
startdate, err := info.GetString(m, "startdate")
if err != nil {
return nil, err
}
startDateTime, err := time.Parse(format, startdate)
if err != nil {
return nil, err
}
enddate, err := info.GetString(m, "enddate")
if err != nil {
return nil, err
}
endDateTime, err := time.Parse(format, enddate)
if err != nil {
return nil, err
}
return DateRange(startDateTime, endDateTime).Format(format), nil
},
})
AddFuncLookup("pasttime", Info{
Display: "PastTime",
Category: "time",
Description: "Date that has occurred before the current moment in time",
Example: "2007-01-24 13:00:35.820738079 +0000 UTC",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return pastDate(r), nil
},
})
AddFuncLookup("futuretime", Info{
Display: "FutureTime",
Category: "time",
Description: "Date that has occurred after the current moment in time",
Example: "2107-01-24 13:00:35.820738079 +0000 UTC",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return futureDate(r), nil
},
})
AddFuncLookup("nanosecond", Info{
Display: "Nanosecond",
Category: "time",
Description: "Unit of time equal to One billionth (10^-9) of a second",
Example: "196446360",
Output: "int",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return nanoSecond(r), nil
},
})
AddFuncLookup("second", Info{
Display: "Second",
Category: "time",
Description: "Unit of time equal to 1/60th of a minute",
Example: "43",
Output: "int",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return second(r), nil
},
})
AddFuncLookup("minute", Info{
Display: "Minute",
Category: "time",
Description: "Unit of time equal to 60 seconds",
Example: "34",
Output: "int",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return minute(r), nil
},
})
AddFuncLookup("hour", Info{
Display: "Hour",
Category: "time",
Description: "Unit of time equal to 60 minutes",
Example: "8",
Output: "int",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return hour(r), nil
},
})
AddFuncLookup("day", Info{
Display: "Day",
Category: "time",
Description: "24-hour period equivalent to one rotation of Earth on its axis",
Example: "12",
Output: "int",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return day(r), nil
},
})
AddFuncLookup("weekday", Info{
Display: "Weekday",
Category: "time",
Description: "Day of the week excluding the weekend",
Example: "Friday",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return weekDay(r), nil
},
})
AddFuncLookup("month", Info{
Display: "Month",
Category: "time",
Description: "Division of the year, typically 30 or 31 days long",
Example: "1",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return month(r), nil
},
})
AddFuncLookup("monthstring", Info{
Display: "Month String",
Category: "time",
Description: "String Representation of a month name",
Example: "September",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return monthString(r), nil
},
})
AddFuncLookup("year", Info{
Display: "Year",
Category: "time",
Description: "Period of 365 days, the time Earth takes to orbit the Sun",
Example: "1900",
Output: "int",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return year(r), nil
},
})
AddFuncLookup("timezone", Info{
Display: "Timezone",
Category: "time",
Description: "Region where the same standard time is used, based on longitudinal divisions of the Earth",
Example: "Kaliningrad Standard Time",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return timeZone(r), nil
},
})
AddFuncLookup("timezoneabv", Info{
Display: "Timezone Abbreviation",
Category: "time",
Description: "Abbreviated 3-letter word of a timezone",
Example: "KST",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return timeZoneAbv(r), nil
},
})
AddFuncLookup("timezonefull", Info{
Display: "Timezone Full",
Category: "time",
Description: "Full name of a timezone",
Example: "(UTC+03:00) Kaliningrad, Minsk",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return timeZoneFull(r), nil
},
})
AddFuncLookup("timezoneoffset", Info{
Display: "Timezone Offset",
Category: "time",
Description: "The difference in hours from Coordinated Universal Time (UTC) for a specific region",
Example: "3",
Output: "float32",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return timeZoneOffset(r), nil
},
})
AddFuncLookup("timezoneregion", Info{
Display: "Timezone Region",
Category: "time",
Description: "Geographic area sharing the same standard time",
Example: "America/Alaska",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return timeZoneRegion(r), nil
},
})
}

107
vendor/github.com/brianvoe/gofakeit/v6/weighted.go generated vendored Normal file
View File

@ -0,0 +1,107 @@
package gofakeit
import (
"errors"
"math/rand"
)
// Weighted will take in an array of options and weights and return a random selection based upon its indexed weight
func Weighted(options []any, weights []float32) (any, error) {
return weighted(globalFaker.Rand, options, weights)
}
// Weighted will take in an array of options and weights and return a random selection based upon its indexed weight
func (f *Faker) Weighted(options []any, weights []float32) (any, error) {
return weighted(f.Rand, options, weights)
}
// Weighted will take in an array of options and weights and return a random selection based upon its indexed weight
func weighted(r *rand.Rand, options []any, weights []float32) (any, error) {
ol := len(options)
wl := len(weights)
// If options length is 1 just return it back
if ol == 1 {
return options[0], nil
}
// Make sure they are passing in options
if ol == 0 {
return nil, errors.New("didnt pass options")
}
// Make sure they are passing in weights
if wl == 0 {
return nil, errors.New("didnt pass weights")
}
// Make sure they are passing in the same length
if ol != wl {
return nil, errors.New("options and weights need to be the same length")
}
// Compute the discrete cumulative density from the sum of the weights
cdf := make([]float32, wl)
var sumOfWeights float32 = 0.0
for i, weight := range weights {
if i > 0 {
cdf[i] = cdf[i-1] + weight
sumOfWeights += weight
continue
}
cdf[i] = weight
sumOfWeights += weight
}
// Get rand value from a multple of sumOfWeights
randSumOfWeights := r.Float32() * sumOfWeights
var l int = 0
var h int = wl - 1
for l <= h {
m := l + (h-l)/2
if randSumOfWeights <= cdf[m] {
if m == 0 || (m > 0 && randSumOfWeights > cdf[m-1]) {
return options[m], nil
}
h = m - 1
} else {
l = m + 1
}
}
return nil, errors.New("end of function")
}
func addWeightedLookup() {
AddFuncLookup("weighted", Info{
Display: "Weighted",
Category: "misc",
Description: "Randomly select a given option based upon an equal amount of weights",
Example: "[hello, 2, 6.9],[1, 2, 3] => 6.9",
Output: "any",
Params: []Param{
{Field: "options", Display: "Options", Type: "[]string", Description: "Array of any values"},
{Field: "weights", Display: "Weights", Type: "[]float", Description: "Array of weights"},
},
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
options, err := info.GetStringArray(m, "options")
if err != nil {
return nil, err
}
weights, err := info.GetFloat32Array(m, "weights")
if err != nil {
return nil, err
}
optionsInterface := make([]any, len(options))
for i, o := range options {
optionsInterface[i] = o
}
return weighted(r, optionsInterface, weights)
},
})
}

182
vendor/github.com/brianvoe/gofakeit/v6/word_adjective.go generated vendored Normal file
View File

@ -0,0 +1,182 @@
package gofakeit
import "math/rand"
// Adjective will generate a random adjective
func Adjective() string { return adjective(globalFaker.Rand) }
// Adjective will generate a random adjective
func (f *Faker) Adjective() string { return adjective(f.Rand) }
func adjective(r *rand.Rand) string {
var adjType = map[int]string{
0: "adjective_descriptive",
1: "adjective_quantitative",
2: "adjective_proper",
3: "adjective_demonstrative",
4: "adjective_possessive",
5: "adjective_interrogative",
6: "adjective_indefinite",
}
return getRandValue(r, []string{"word", adjType[number(r, 0, 6)]})
}
// AdjectiveDescriptive will generate a random descriptive adjective
func AdjectiveDescriptive() string { return adjectiveDescriptive(globalFaker.Rand) }
// AdjectiveDescriptive will generate a random descriptive adjective
func (f *Faker) AdjectiveDescriptive() string { return adjectiveDescriptive(f.Rand) }
func adjectiveDescriptive(r *rand.Rand) string {
return getRandValue(r, []string{"word", "adjective_descriptive"})
}
// AdjectiveQuantitative will generate a random quantitative adjective
func AdjectiveQuantitative() string { return adjectiveQuantitative(globalFaker.Rand) }
// AdjectiveQuantitative will generate a random quantitative adjective
func (f *Faker) AdjectiveQuantitative() string { return adjectiveQuantitative(f.Rand) }
func adjectiveQuantitative(r *rand.Rand) string {
return getRandValue(r, []string{"word", "adjective_quantitative"})
}
// AdjectiveProper will generate a random proper adjective
func AdjectiveProper() string { return adjectiveProper(globalFaker.Rand) }
// AdjectiveProper will generate a random proper adjective
func (f *Faker) AdjectiveProper() string { return adjectiveProper(f.Rand) }
func adjectiveProper(r *rand.Rand) string {
return getRandValue(r, []string{"word", "adjective_proper"})
}
// AdjectiveDemonstrative will generate a random demonstrative adjective
func AdjectiveDemonstrative() string { return adjectiveDemonstrative(globalFaker.Rand) }
// AdjectiveDemonstrative will generate a random demonstrative adjective
func (f *Faker) AdjectiveDemonstrative() string { return adjectiveDemonstrative(f.Rand) }
func adjectiveDemonstrative(r *rand.Rand) string {
return getRandValue(r, []string{"word", "adjective_demonstrative"})
}
// AdjectivePossessive will generate a random possessive adjective
func AdjectivePossessive() string { return adjectivePossessive(globalFaker.Rand) }
// AdjectivePossessive will generate a random possessive adjective
func (f *Faker) AdjectivePossessive() string { return adjectivePossessive(f.Rand) }
func adjectivePossessive(r *rand.Rand) string {
return getRandValue(r, []string{"word", "adjective_possessive"})
}
// AdjectiveInterrogative will generate a random interrogative adjective
func AdjectiveInterrogative() string { return adjectiveInterrogative(globalFaker.Rand) }
// AdjectiveInterrogative will generate a random interrogative adjective
func (f *Faker) AdjectiveInterrogative() string { return adjectiveInterrogative(f.Rand) }
func adjectiveInterrogative(r *rand.Rand) string {
return getRandValue(r, []string{"word", "adjective_interrogative"})
}
// AdjectiveIndefinite will generate a random indefinite adjective
func AdjectiveIndefinite() string { return adjectiveIndefinite(globalFaker.Rand) }
// AdjectiveIndefinite will generate a random indefinite adjective
func (f *Faker) AdjectiveIndefinite() string { return adjectiveIndefinite(f.Rand) }
func adjectiveIndefinite(r *rand.Rand) string {
return getRandValue(r, []string{"word", "adjective_indefinite"})
}
func addWordAdjectiveLookup() {
AddFuncLookup("adjective", Info{
Display: "Adjective",
Category: "word",
Description: "Word describing or modifying a noun",
Example: "genuine",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return adjective(r), nil
},
})
AddFuncLookup("adjectivedescriptive", Info{
Display: "Descriptive Adjective",
Category: "word",
Description: "Adjective that provides detailed characteristics about a noun",
Example: "brave",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return adjectiveDescriptive(r), nil
},
})
AddFuncLookup("adjectivequantitative", Info{
Display: "Quantitative Adjective",
Category: "word",
Description: "Adjective that indicates the quantity or amount of something",
Example: "a little",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return adjectiveQuantitative(r), nil
},
})
AddFuncLookup("adjectiveproper", Info{
Display: "Proper Adjective",
Category: "word",
Description: "Adjective derived from a proper noun, often used to describe nationality or origin",
Example: "Afghan",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return adjectiveProper(r), nil
},
})
AddFuncLookup("adjectivedemonstrative", Info{
Display: "Demonstrative Adjective",
Category: "word",
Description: "Adjective used to point out specific things",
Example: "this",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return adjectiveDemonstrative(r), nil
},
})
AddFuncLookup("adjectivepossessive", Info{
Display: "Possessive Adjective",
Category: "word",
Description: "Adjective indicating ownership or possession",
Example: "my",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return adjectivePossessive(r), nil
},
})
AddFuncLookup("adjectiveinterrogative", Info{
Display: "Interrogative Adjective",
Category: "word",
Description: "Adjective used to ask questions",
Example: "what",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return adjectiveInterrogative(r), nil
},
})
AddFuncLookup("adjectiveindefinite", Info{
Display: "Indefinite Adjective",
Category: "word",
Description: "Adjective describing a non-specific noun",
Example: "few",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return adjectiveIndefinite(r), nil
},
})
}

176
vendor/github.com/brianvoe/gofakeit/v6/word_adverb.go generated vendored Normal file
View File

@ -0,0 +1,176 @@
package gofakeit
import "math/rand"
// Adverb will generate a random adverb
func Adverb() string { return adverb(globalFaker.Rand) }
// Adverb will generate a random adverb
func (f *Faker) Adverb() string { return adverb(f.Rand) }
func adverb(r *rand.Rand) string {
var adverbType = map[int]string{
0: "adverb_manner",
1: "adverb_degree",
2: "adverb_place",
3: "adverb_time_definite",
4: "adverb_time_indefinite",
5: "adverb_frequency_definite",
6: "adverb_frequency_indefinite",
}
return getRandValue(r, []string{"word", adverbType[number(r, 0, 6)]})
}
// AdverbManner will generate a random manner adverb
func AdverbManner() string { return adverbManner(globalFaker.Rand) }
// AdverbManner will generate a random manner adverb
func (f *Faker) AdverbManner() string { return adverbManner(f.Rand) }
func adverbManner(r *rand.Rand) string { return getRandValue(r, []string{"word", "adverb_manner"}) }
// AdverbDegree will generate a random degree adverb
func AdverbDegree() string { return adverbDegree(globalFaker.Rand) }
// AdverbDegree will generate a random degree adverb
func (f *Faker) AdverbDegree() string { return adverbDegree(f.Rand) }
func adverbDegree(r *rand.Rand) string { return getRandValue(r, []string{"word", "adverb_degree"}) }
// AdverbPlace will generate a random place adverb
func AdverbPlace() string { return adverbPlace(globalFaker.Rand) }
// AdverbPlace will generate a random place adverb
func (f *Faker) AdverbPlace() string { return adverbPlace(f.Rand) }
func adverbPlace(r *rand.Rand) string { return getRandValue(r, []string{"word", "adverb_place"}) }
// AdverbTimeDefinite will generate a random time definite adverb
func AdverbTimeDefinite() string { return adverbTimeDefinite(globalFaker.Rand) }
// AdverbTimeDefinite will generate a random time definite adverb
func (f *Faker) AdverbTimeDefinite() string { return adverbTimeDefinite(f.Rand) }
func adverbTimeDefinite(r *rand.Rand) string {
return getRandValue(r, []string{"word", "adverb_time_definite"})
}
// AdverbTimeIndefinite will generate a random time indefinite adverb
func AdverbTimeIndefinite() string { return adverbTimeIndefinite(globalFaker.Rand) }
// AdverbTimeIndefinite will generate a random time indefinite adverb
func (f *Faker) AdverbTimeIndefinite() string { return adverbTimeIndefinite(f.Rand) }
func adverbTimeIndefinite(r *rand.Rand) string {
return getRandValue(r, []string{"word", "adverb_time_indefinite"})
}
// AdverbFrequencyDefinite will generate a random frequency definite adverb
func AdverbFrequencyDefinite() string { return adverbFrequencyDefinite(globalFaker.Rand) }
// AdverbFrequencyDefinite will generate a random frequency definite adverb
func (f *Faker) AdverbFrequencyDefinite() string { return adverbFrequencyDefinite(f.Rand) }
func adverbFrequencyDefinite(r *rand.Rand) string {
return getRandValue(r, []string{"word", "adverb_frequency_definite"})
}
// AdverbFrequencyIndefinite will generate a random frequency indefinite adverb
func AdverbFrequencyIndefinite() string { return adverbFrequencyIndefinite(globalFaker.Rand) }
// AdverbFrequencyIndefinite will generate a random frequency indefinite adverb
func (f *Faker) AdverbFrequencyIndefinite() string { return adverbFrequencyIndefinite(f.Rand) }
func adverbFrequencyIndefinite(r *rand.Rand) string {
return getRandValue(r, []string{"word", "adverb_frequency_indefinite"})
}
func addWordAdverbLookup() {
AddFuncLookup("adverb", Info{
Display: "Adverb",
Category: "word",
Description: "Word that modifies verbs, adjectives, or other adverbs",
Example: "smoothly",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return adverb(r), nil
},
})
AddFuncLookup("adverbmanner", Info{
Display: "Adverb Manner",
Category: "word",
Description: "Adverb that describes how an action is performed",
Example: "stupidly",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return adverbManner(r), nil
},
})
AddFuncLookup("adverbdegree", Info{
Display: "Adverb Degree",
Category: "word",
Description: "Adverb that indicates the degree or intensity of an action or adjective",
Example: "intensely",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return adverbDegree(r), nil
},
})
AddFuncLookup("adverbplace", Info{
Display: "Adverb Place",
Category: "word",
Description: "Adverb that indicates the location or direction of an action",
Example: "east",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return adverbPlace(r), nil
},
})
AddFuncLookup("adverbtimedefinite", Info{
Display: "Adverb Time Definite",
Category: "word",
Description: "Adverb that specifies the exact time an action occurs",
Example: "now",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return adverbTimeDefinite(r), nil
},
})
AddFuncLookup("adverbtimeindefinite", Info{
Display: "Adverb Time Indefinite",
Category: "word",
Description: "Adverb that gives a general or unspecified time frame",
Example: "already",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return adverbTimeIndefinite(r), nil
},
})
AddFuncLookup("adverbfrequencydefinite", Info{
Display: "Adverb Frequency Definite",
Category: "word",
Description: "Adverb that specifies how often an action occurs with a clear frequency",
Example: "hourly",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return adverbFrequencyDefinite(r), nil
},
})
AddFuncLookup("adverbfrequencyindefinite", Info{
Display: "Adverb Frequency Indefinite",
Category: "word",
Description: "Adverb that specifies how often an action occurs without specifying a particular frequency",
Example: "occasionally",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return adverbFrequencyIndefinite(r), nil
},
})
}

73
vendor/github.com/brianvoe/gofakeit/v6/word_comment.go generated vendored Normal file
View File

@ -0,0 +1,73 @@
package gofakeit
import (
"math/rand"
"strings"
)
// Comment will generate a random statement or remark expressing an opinion, observation, or reaction
func Comment() string { return comment(globalFaker.Rand) }
// Comment will generate a random statement or remark expressing an opinion, observation, or reaction
func (f *Faker) Comment() string { return comment(f.Rand) }
func comment(r *rand.Rand) string {
structures := [][]string{
{"interjection", "adjective", "noun", "verb", "adverb"},
{"noun", "verb", "preposition", "determiner", "adjective", "noun"},
{"noun", "verb", "adverb"},
{"adjective", "noun", "verb"},
{"noun", "verb", "preposition", "noun"},
}
// Randomly select a structure
structure := structures[number(r, 0, len(structures)-1)]
// Build the sentence
var commentParts []string
for _, wordType := range structure {
switch wordType {
case "noun":
commentParts = append(commentParts, noun(r))
case "verb":
commentParts = append(commentParts, verb(r))
case "adjective":
commentParts = append(commentParts, adjective(r))
case "adverb":
commentParts = append(commentParts, adverb(r))
case "interjection":
commentParts = append(commentParts, interjection(r))
case "preposition":
commentParts = append(commentParts, preposition(r))
case "determiner":
commentParts = append(commentParts, nounDeterminer(r))
default:
// Should never hit
panic("Invalid word type")
}
}
// Combine the words into a sentence
sentence := strings.Join(commentParts, " ")
// Capitalize the first letter
sentence = title(sentence)
// Add a period to the end of the sentence
sentence = sentence + "."
return sentence
}
func addWordCommentLookup() {
AddFuncLookup("comment", Info{
Display: "Comment",
Category: "word",
Description: "Statement or remark expressing an opinion, observation, or reaction",
Example: "wow",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return interjection(r), nil
},
})
}

161
vendor/github.com/brianvoe/gofakeit/v6/word_connective.go generated vendored Normal file
View File

@ -0,0 +1,161 @@
package gofakeit
import "math/rand"
// Connective will generate a random connective
func Connective() string { return connective(globalFaker.Rand) }
// Connective will generate a random connective
func (f *Faker) Connective() string { return connective(f.Rand) }
func connective(r *rand.Rand) string {
var connectiveType = map[int]string{
0: "connective_time",
1: "connective_comparative",
2: "connective_complaint",
3: "connective_listing",
4: "connective_casual",
5: "connective_examplify",
}
return getRandValue(r, []string{"word", connectiveType[number(r, 0, 5)]})
}
// ConnectiveTime will generate a random connective time
func ConnectiveTime() string { return connectiveTime(globalFaker.Rand) }
// ConnectiveTime will generate a random connective time
func (f *Faker) ConnectiveTime() string { return connectiveTime(f.Rand) }
func connectiveTime(r *rand.Rand) string {
return getRandValue(r, []string{"word", "connective_time"})
}
// ConnectiveComparative will generate a random comparative connective
func ConnectiveComparative() string { return connectiveComparative(globalFaker.Rand) }
// ConnectiveComparative will generate a random comparative connective
func (f *Faker) ConnectiveComparative() string { return connectiveComparative(f.Rand) }
func connectiveComparative(r *rand.Rand) string {
return getRandValue(r, []string{"word", "connective_comparative"})
}
// ConnectiveComplaint will generate a random complaint connective
func ConnectiveComplaint() string { return connectiveComplaint(globalFaker.Rand) }
// ConnectiveComplaint will generate a random complaint connective
func (f *Faker) ConnectiveComplaint() string { return connectiveComplaint(f.Rand) }
func connectiveComplaint(r *rand.Rand) string {
return getRandValue(r, []string{"word", "connective_complaint"})
}
// ConnectiveListing will generate a random listing connective
func ConnectiveListing() string { return connectiveListing(globalFaker.Rand) }
// ConnectiveListing will generate a random listing connective
func (f *Faker) ConnectiveListing() string { return connectiveListing(f.Rand) }
func connectiveListing(r *rand.Rand) string {
return getRandValue(r, []string{"word", "connective_listing"})
}
// ConnectiveCasual will generate a random casual connective
func ConnectiveCasual() string { return connectiveCasual(globalFaker.Rand) }
// ConnectiveCasual will generate a random casual connective
func (f *Faker) ConnectiveCasual() string { return connectiveCasual(f.Rand) }
func connectiveCasual(r *rand.Rand) string {
return getRandValue(r, []string{"word", "connective_casual"})
}
// ConnectiveExamplify will generate a random examplify connective
func ConnectiveExamplify() string { return connectiveExamplify(globalFaker.Rand) }
// ConnectiveExamplify will generate a random examplify connective
func (f *Faker) ConnectiveExamplify() string { return connectiveExamplify(f.Rand) }
func connectiveExamplify(r *rand.Rand) string {
return getRandValue(r, []string{"word", "connective_examplify"})
}
func addWordConnectiveLookup() {
AddFuncLookup("connective", Info{
Display: "Connective",
Category: "word",
Description: "Word used to connect words or sentences",
Example: "such as",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return connective(r), nil
},
})
AddFuncLookup("connectivetime", Info{
Display: "Connective Time",
Category: "word",
Description: "Connective word used to indicate a temporal relationship between events or actions",
Example: "finally",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return connectiveTime(r), nil
},
})
AddFuncLookup("connectivecomparative", Info{
Display: "Connective Comparitive",
Category: "word",
Description: "Connective word used to indicate a comparison between two or more things",
Example: "in addition",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return connectiveComparative(r), nil
},
})
AddFuncLookup("connectivecomplaint", Info{
Display: "Connective Complaint",
Category: "word",
Description: "Connective word used to express dissatisfaction or complaints about a situation",
Example: "besides",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return connectiveComplaint(r), nil
},
})
AddFuncLookup("connectivelisting", Info{
Display: "Connective Listing",
Category: "word",
Description: "Connective word used to list or enumerate items or examples",
Example: "firstly",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return connectiveListing(r), nil
},
})
AddFuncLookup("connectivecasual", Info{
Display: "Connective Casual",
Category: "word",
Description: "Connective word used to indicate a cause-and-effect relationship between events or actions",
Example: "an outcome of",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return connectiveCasual(r), nil
},
})
AddFuncLookup("connectiveexamplify", Info{
Display: "Connective Examplify",
Category: "word",
Description: "Connective word used to provide examples or illustrations of a concept or idea",
Example: "then",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return connectiveExamplify(r), nil
},
})
}

38
vendor/github.com/brianvoe/gofakeit/v6/word_general.go generated vendored Normal file
View File

@ -0,0 +1,38 @@
package gofakeit
import (
"math/rand"
"strings"
"github.com/brianvoe/gofakeit/v6/data"
)
// Word will generate a random word
func Word() string { return word(globalFaker.Rand) }
// Word will generate a random word
func (f *Faker) Word() string { return word(f.Rand) }
func word(r *rand.Rand) string {
word := getRandValue(r, []string{"word", randomString(r, data.WordKeys)})
// Word may return a couple of words, if so we will split on space and return a random word
if strings.Contains(word, " ") {
return randomString(r, strings.Split(word, " "))
}
return word
}
func addWordGeneralLookup() {
AddFuncLookup("word", Info{
Display: "Word",
Category: "word",
Description: "Basic unit of language representing a concept or thing, consisting of letters and having meaning",
Example: "man",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return word(r), nil
},
})
}

35
vendor/github.com/brianvoe/gofakeit/v6/word_grammar.go generated vendored Normal file
View File

@ -0,0 +1,35 @@
package gofakeit
import (
"math/rand"
"unicode"
)
// SentenceSimple will generate a random simple sentence
func SentenceSimple() string { return sentenceSimple(globalFaker.Rand) }
// SentenceSimple will generate a random simple sentence
func (f *Faker) SentenceSimple() string { return sentenceSimple(f.Rand) }
func sentenceSimple(r *rand.Rand) string {
// simple sentence consists of a noun phrase and a verb phrase
str := phraseNoun(r) + " " + phraseVerb(r) + "."
// capitalize the first letter
strR := []rune(str)
strR[0] = unicode.ToUpper(strR[0])
return string(strR)
}
func addWordGrammerLookup() {
AddFuncLookup("sentencesimple", Info{
Display: "Simple Sentence",
Category: "word",
Description: "Group of words that expresses a complete thought",
Example: "A tribe fly the lemony kitchen.",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return sentenceSimple(r), nil
},
})
}

45
vendor/github.com/brianvoe/gofakeit/v6/word_helper.go generated vendored Normal file
View File

@ -0,0 +1,45 @@
package gofakeit
import (
"strings"
)
// This will look at a few things to determine what kind of article to use for the word
func getArticle(word string) string {
// If nothing is passed return empty
if word == "" {
return ""
}
word = strings.ToLower(word)
letters := strings.Split(word, "")
firstLetter := ""
secondLetter := ""
if len(letters) > 0 {
firstLetter = letters[0]
}
if len(letters) > 1 {
secondLetter = letters[1]
}
// If the word starts with a, e, i, o, use an article
if firstLetter == "a" || firstLetter == "e" || firstLetter == "i" || firstLetter == "o" {
return "an"
}
// If the word starts with a u and n or l, use an article
if firstLetter == "u" {
if secondLetter == "n" || secondLetter == "l" {
return "an"
}
}
// If the word starts with a vowel, use an article
if firstLetter == "h" {
if secondLetter == "i" {
return "an"
}
}
return "a"
}

Some files were not shown because too many files have changed in this diff Show More