Engage!

1 files changed, 302 insertions, 0 deletions

diff --git a/vendor/github.com/go-faker/faker/v4/internet.go b/vendor/github.com/go-faker/faker/v4/internet.go
new file mode 100644
index 0000000..3035ad8
--- /dev/null
+++ b/vendor/github.com/go-faker/faker/v4/internet.go
@@ -0,0 +1,302 @@
+package faker
+
+import (
+	"fmt"
+	"net"
+	"reflect"
+	"strings"
+
+	"github.com/go-faker/faker/v4/pkg/options"
+)
+
+var tld = []string{"com", "biz", "info", "net", "org", "ru", "edu", "top"}
+var urlFormats = []string{
+	"http://www.%s/",
+	"https://www.%s/",
+	"http://%s/",
+	"https://%s/",
+	"http://www.%s/%s",
+	"https://www.%s/%s",
+	"http://%s/%s",
+	"https://%s/%s",
+	"http://%s/%s.html",
+	"https://%s/%s.html",
+	"http://%s/%s.php",
+	"https://%s/%s.php",
+	"http://%s/%s.jpg",
+	"https://%s/%s.jpg",
+	"http://%s/%s.webp",
+	"https://%s/%s.webp",
+	"http://%s/%s.js",
+	"https://%s/%s.js",
+	"http://%s/%s.css",
+	"https://%s/%s.css",
+	"http://%s/%s.svg",
+	"https://%s/%s.svg",
+}
+
+// GetNetworker returns a new Networker interface of Internet
+func GetNetworker(opts ...options.OptionFunc) Networker {
+	opt := options.BuildOptions(opts)
+	internet := &Internet{
+		fakerOption: *opt,
+	}
+	return internet
+}
+
+// Networker is logical layer for Internet
+type Networker interface {
+	Email(v reflect.Value) (interface{}, error)
+	MacAddress(v reflect.Value) (interface{}, error)
+	DomainName(v reflect.Value) (interface{}, error)
+	URL(v reflect.Value) (interface{}, error)
+	UserName(v reflect.Value) (interface{}, error)
+	IPv4(v reflect.Value) (interface{}, error)
+	IPv6(v reflect.Value) (interface{}, error)
+	Password(v reflect.Value) (interface{}, error)
+	Jwt(v reflect.Value) (interface{}, error)
+}
+
+// Internet struct
+type Internet struct {
+	fakerOption options.Options
+}
+
+func (internet Internet) email() (string, error) {
+	var err error
+	var emailName, emailDomain string
+	if emailName, err = randomString(7, internet.fakerOption); err != nil {
+		return "", err
+	}
+
+	if internet.fakerOption.CustomDomain != nil {
+		emailDomain = *internet.fakerOption.CustomDomain
+	} else {
+		randDomain, err := randomString(7, internet.fakerOption)
+		if err != nil {
+			return "", err
+		}
+
+		emailDomain = randDomain + "." + randomElementFromSliceString(tld)
+	}
+
+	return (emailName + "@" + emailDomain), nil
+}
+
+// Email generates random email id
+func (internet Internet) Email(v reflect.Value) (interface{}, error) {
+	return internet.email()
+}
+
+// Email get email randomly in string
+func Email(opts ...options.OptionFunc) string {
+	return singleFakeData(EmailTag, func() interface{} {
+		opt := options.BuildOptions(opts)
+		i := Internet{fakerOption: *opt}
+		r, err := i.email()
+		if err != nil {
+			panic(err.Error())
+		}
+		return r
+	}, opts...).(string)
+}
+
+func (internet Internet) macAddress() string {
+	ip := make([]byte, 6)
+	for i := 0; i < 6; i++ {
+		ip[i] = byte(rand.Intn(256))
+	}
+	return net.HardwareAddr(ip).String()
+}
+
+// MacAddress generates random MacAddress
+func (internet Internet) MacAddress(v reflect.Value) (interface{}, error) {
+	return internet.macAddress(), nil
+}
+
+// MacAddress get mac address randomly in string
+func MacAddress(opts ...options.OptionFunc) string {
+	return singleFakeData(MacAddressTag, func() interface{} {
+		opt := options.BuildOptions(opts)
+		i := Internet{fakerOption: *opt}
+		return i.macAddress()
+	}, opts...).(string)
+}
+
+func (internet Internet) domainName() (string, error) {
+	domainPart, err := randomString(7, internet.fakerOption)
+	if err != nil {
+		return "", err
+	}
+	return (strings.ToLower(domainPart) + "." + randomElementFromSliceString(tld)), nil
+}
+
+// DomainName generates random domain name
+func (internet Internet) DomainName(v reflect.Value) (interface{}, error) {
+	return internet.domainName()
+}
+
+// DomainName get email domain name in string
+func DomainName(opts ...options.OptionFunc) string {
+	return singleFakeData(DomainNameTag, func() interface{} {
+		opt := options.BuildOptions(opts)
+		i := Internet{fakerOption: *opt}
+		d, err := i.domainName()
+		if err != nil {
+			panic(err.Error())
+		}
+		return d
+	}, opts...).(string)
+}
+
+func (internet Internet) url() (string, error) {
+	format := randomElementFromSliceString(urlFormats)
+	countVerbs := strings.Count(format, "%s")
+	d, err := internet.domainName()
+	if err != nil {
+		return "", nil
+	}
+	if countVerbs == 1 {
+		return fmt.Sprintf(format, d), nil
+	}
+	u, err := internet.username()
+	if err != nil {
+		return "", err
+	}
+	return fmt.Sprintf(format, d, u), nil
+}
+
+// URL generates random URL standardized in urlFormats const
+func (internet Internet) URL(v reflect.Value) (interface{}, error) {
+	return internet.url()
+}
+
+// URL get Url randomly in string
+func URL(opts ...options.OptionFunc) string {
+	return singleFakeData(URLTag, func() interface{} {
+		opt := options.BuildOptions(opts)
+		i := Internet{fakerOption: *opt}
+		u, err := i.url()
+		if err != nil {
+			panic(err.Error())
+		}
+		return u
+	}, opts...).(string)
+}
+
+func (internet Internet) username() (string, error) {
+	return randomString(7, internet.fakerOption)
+}
+
+// UserName generates random username
+func (internet Internet) UserName(v reflect.Value) (interface{}, error) {
+	return internet.username()
+}
+
+// Username get username randomly in string
+func Username(opts ...options.OptionFunc) string {
+	return singleFakeData(UserNameTag, func() interface{} {
+		opt := options.BuildOptions(opts)
+		i := Internet{fakerOption: *opt}
+		u, err := i.username()
+		if err != nil {
+			panic(err.Error())
+		}
+		return u
+	}, opts...).(string)
+}
+
+func (internet Internet) ipv4() string {
+	size := 4
+	ip := make([]byte, size)
+	for i := 0; i < size; i++ {
+		ip[i] = byte(rand.Intn(256))
+	}
+	return net.IP(ip).To4().String()
+}
+
+// IPv4 generates random IPv4 address
+func (internet Internet) IPv4(v reflect.Value) (interface{}, error) {
+	return internet.ipv4(), nil
+}
+
+// IPv4 get IPv4 randomly in string
+func IPv4(opts ...options.OptionFunc) string {
+	return singleFakeData(IPV4Tag, func() interface{} {
+		opt := options.BuildOptions(opts)
+		i := Internet{fakerOption: *opt}
+		return i.ipv4()
+	}, opts...).(string)
+}
+
+func (internet Internet) ipv6() string {
+	size := 16
+	ip := make([]byte, size)
+	for i := 0; i < size; i++ {
+		ip[i] = byte(rand.Intn(256))
+	}
+	return net.IP(ip).To16().String()
+}
+
+// IPv6 generates random IPv6 address
+func (internet Internet) IPv6(v reflect.Value) (interface{}, error) {
+	return internet.ipv6(), nil
+}
+
+// IPv6 get IPv6 randomly in string
+func IPv6(opts ...options.OptionFunc) string {
+	return singleFakeData(IPV6Tag, func() interface{} {
+		opt := options.BuildOptions(opts)
+		i := Internet{fakerOption: *opt}
+		return i.ipv6()
+	}, opts...).(string)
+}
+
+func (internet Internet) password() (string, error) {
+	return randomString(50, internet.fakerOption)
+}
+
+// Password returns a hashed password
+func (internet Internet) Password(v reflect.Value) (interface{}, error) {
+	return internet.password()
+}
+
+// Password get password randomly in string
+func Password(opts ...options.OptionFunc) string {
+	return singleFakeData(PASSWORD, func() interface{} {
+		opt := options.BuildOptions(opts)
+		i := Internet{fakerOption: *opt}
+		p, err := i.password()
+		if err != nil {
+			panic(err.Error())
+		}
+		return p
+	}, opts...).(string)
+}
+
+func (internet Internet) jwt() (string, error) {
+	element, err := randomString(40, internet.fakerOption)
+	sl := element[:]
+	if err != nil {
+		return "", err
+	}
+	return strings.Join([]string{sl, sl, sl}, "."), nil
+}
+
+// Jwt returns a jwt-like random string in xxxx.yyyy.zzzz style
+func (internet Internet) Jwt(v reflect.Value) (interface{}, error) {
+	return internet.jwt()
+}
+
+// Jwt get jwt-like string
+func Jwt(opts ...options.OptionFunc) string {
+	return singleFakeData(JWT, func() interface{} {
+		opt := options.BuildOptions(opts)
+		i := Internet{fakerOption: *opt}
+		p, err := i.jwt()
+		if err != nil {
+			panic(err.Error())
+		}
+		return p
+	}, opts...).(string)
+}