Class: Faker::Internet

Inherits:
Base
  • Object
show all
Extended by:
Gem::Deprecate
Defined in:
lib/faker/default/internet.rb,
lib/faker/default/internet_http.rb

Defined Under Namespace

Classes: HTTP

Constant Summary collapse

PRIVATE_IPV4_ADDRESS_RANGES =

Private, Host, and Link-Local network address blocks as defined in en.wikipedia.org/wiki/IPv4#Special-use_addresses

[
  [10..10,   0..255,   0..255, 1..255], # 10.0.0.0/8     - Used for local communications within a private network
  [100..100, 64..127,  0..255, 1..255], # 100.64.0.0/10  - Shared address space for communications between an ISP and its subscribers
  [127..127, 0..255,   0..255, 1..255], # 127.0.0.0/8    - Used for loopback addresses to the local host
  [169..169, 254..254, 0..255, 1..255], # 169.254.0.0/16 - Used for link-local addresses between two hosts on a single link when
  [172..172, 16..31,   0..255, 1..255], # 172.16.0.0/12  - Used for local communications within a private network
  [192..192, 0..0,     0..0,   1..255], # 192.0.0.0/24   - IETF Protocol Assignments
  [192..192, 168..168, 0..255, 1..255], # 192.168.0.0/16 - Used for local communications within a private network
  [198..198, 18..19,   0..255, 1..255]  # 198.18.0.0/15  - Used for benchmark testing of inter-network communications between subnets
].each(&:freeze).freeze

Constants inherited from Base

Base::LLetters, Base::Letters, Base::NOT_GIVEN, Base::Numbers, Base::ULetters

Class Method Summary collapse

Methods inherited from Base

bothify, disable_enforce_available_locales, fetch, fetch_all, flexible, generate, letterify, method_missing, numerify, parse, rand, rand_in_range, regexify, resolve, respond_to_missing?, sample, shuffle, translate, unique, with_locale

Class Method Details

.base64(length: 16, padding: false, urlsafe: true) ⇒ String

Produces a random string of alphabetic characters, (no digits)

Examples:

Faker::Internet.base64
  #=> "r_hbZ2DSD-ZACzZT"
Faker::Internet.base64(length: 4, padding: true, urlsafe: false)
  #=> "x1/R="

Parameters:

  • length (Integer) (defaults to: 16)

    The length of the string to generate

  • padding (Boolean) (defaults to: false)

    Toggles if a final equal ‘=’ will be added.

  • urlsafe (Boolean) (defaults to: true)

    Toggles charset to ‘-’ and ‘_’ instead of ‘+’ and ‘/’.

Returns:

  • (String)

Available since:

  • 2.11.0



561
562
563
564
565
566
567
568
569
570
571
# File 'lib/faker/default/internet.rb', line 561

def base64(length: 16, padding: false, urlsafe: true)
  char_range = [
    Array('0'..'9'),
    Array('A'..'Z'),
    Array('a'..'z'),
    urlsafe ? %w[- _] : %w[+ /]
  ].flatten
  s = Array.new(length) { sample(char_range) }.join
  s += '=' if padding
  s
end

.bot_user_agent(vendor: nil) ⇒ String

Generate Web Crawler’s user agents

Examples:

Faker::Internet.bot_user_agent                        #=> "Mozilla/5.0 (compatible; YandexBot/3.0; +http://yandex.com/bots)"
Faker::Internet.bot_user_agent(vendor: 'googlebot')   #=> "Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko; compatible; Googlebot/2.1; +http://www.google.com/bot.html) Chrome/99.0.4844.84 Safari/537.36"
Faker::Internet.bot_user_agent(vendor: 'bingbot')     #=> "Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko; compatible; bingbot/2.0; +http://www.bing.com/bingbot.htm) Chrome/86.0.4240.68 Safari/537.36 Edg/86.0.622.31"

Parameters:

  • vendor (String) (defaults to: nil)

    Name of vendor, supported vendors are googlebot, bingbot, duckduckbot, baiduspider, yandexbot

Returns:

  • (String)


523
524
525
526
527
# File 'lib/faker/default/internet.rb', line 523

def bot_user_agent(vendor: nil)
  agent_hash = translate('faker.internet.bot_user_agent')
  agents = vendor.respond_to?(:to_sym) && agent_hash[vendor.to_sym] || agent_hash[sample(agent_hash.keys)]
  sample(agents)
end

.device_tokenObject

Generates random token

@return

Examples:

Faker::Internet.device_token  #=> "749f535671cf6b34d8e794d212d00c703b96274e07161b18b082d0d70ef1052f"


490
491
492
# File 'lib/faker/default/internet.rb', line 490

def device_token
  shuffle(rand(16**64).to_s(16).rjust(64, '0').chars.to_a).join
end

.domain_name(subdomain: false, domain: nil) ⇒ String

Returns the domain name

Examples:

Faker::Internet.domain_name                                                   #=> "altenwerth-gerhold.example"
Faker::Internet.domain_name(subdomain: true)                                  #=> "metz.mclaughlin-brekke.test"
Faker::Internet.domain_name(subdomain: true, domain: 'faker')                 #=> "foo.faker.test"
Faker::Internet.domain_name(domain: 'faker-ruby.org')                         #=> "faker-ruby.org"
Faker::Internet.domain_name(subdomain: true, domain: 'faker-ruby.org')        #=> "foo.faker-ruby.org"
Faker::Internet.domain_name(subdomain: true, domain: 'faker.faker-ruby.org')  #=> "faker.faker-ruby.org"

Parameters:

  • subdomain (Bool) (defaults to: false)

    If true passed adds a subdomain in response

  • domain (String) (defaults to: nil)

Returns:

  • (String)


226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
# File 'lib/faker/default/internet.rb', line 226

def domain_name(subdomain: false, domain: nil)
  with_locale(:en) do
    if domain
      domain
        .split('.')
        .map { |domain_part| Char.prepare(domain_part) }
        .tap do |domain_elements|
          if domain_elements.length < 2
            domain_elements << domain_suffix(safe: true)
          end
          if subdomain && domain_elements.length < 3
            domain_elements.unshift(Char.prepare(domain_word))
          end
        end.join('.')
    else
      [domain_word, domain_suffix(safe: true)].tap do |domain_elements|
        if subdomain
          domain_elements.unshift(Char.prepare(domain_word))
        end
      end.join('.')
    end
  end
end

.domain_suffix(safe: nil) ⇒ String

Returns the domain suffix e.g. com, org, co, biz, info etc.

Examples:

Faker::Internet.domain_suffix              #=> "com"
Faker::Internet.domain_suffix              #=> "biz"
Faker::Internet.domain_suffix(safe: true)  #=> "example"
Faker::Internet.domain_suffix(safe: true)  #=> "test"

Returns:

  • (String)


285
286
287
288
289
290
291
# File 'lib/faker/default/internet.rb', line 285

def domain_suffix(safe: nil)
  if safe
    fetch('internet.safe_domain_suffix')
  else
    fetch('internet.domain_suffix')
  end
end

.domain_wordString

Returns the domain word for internet

Examples:

Faker::Internet.domain_word   #=> "senger"

Returns:

  • (String)


272
273
274
# File 'lib/faker/default/internet.rb', line 272

def domain_word
  with_locale(:en) { Char.prepare(Company.name.split.first) }
end

.email(name: nil, separators: nil, domain: nil) ⇒ String

Returns the email address

Examples:

Faker::Internet.email                                                           #=> "[email protected]"
Faker::Internet.email(name: 'smith')                                            #=> "[email protected]"
Faker::Internet.email(name: 'sam smith', separators: ['-'])                     #=> "[email protected]"
Faker::Internet.email(name: 'sam smith', separators: ['-'], domain: 'test')     #=> "[email protected]"
Faker::Internet.email(domain: 'gmail.com')                                      #=> "[email protected]"

Parameters:

  • name (String) (defaults to: nil)
  • separators (Array) (defaults to: nil)
  • domain (String) (defaults to: nil)

Returns:

  • (String)


35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
# File 'lib/faker/default/internet.rb', line 35

def email(name: nil, separators: nil, domain: nil)
  local_part = if separators
                 username(specifier: name, separators: separators)
               else
                 username(specifier: name)
               end

  sanitized_local_part = sanitize_email_local_part(local_part)

  generate_domain = if domain.nil?
                      domain_name
                    else
                      domain_name(domain: domain)
                    end

  construct_email(sanitized_local_part, generate_domain)
end

.fix_umlauts(string: '') ⇒ String

Fixes ä, ö, ü, ß characters in string passed with ae, oe, ue, ss resp.

Examples:

Faker::Internet.fix_umlauts                     #=> ""
Faker::Internet.fix_umlauts(string: 'faker')    #=> "faker"
Faker::Internet.fix_umlauts(string: 'faküer')   #=> "fakueer"

Parameters:

  • string (String) (defaults to: '')

Returns:

  • (String)


261
262
263
# File 'lib/faker/default/internet.rb', line 261

def fix_umlauts(string: '')
  Char.fix_umlauts(string)
end

.free_email(name: nil) ⇒ String

Returns the email address with domain either gmail.com, yahoo.com or hotmail.com

Examples:

Faker::Internet.free_email                                                           #=> "[email protected]"
Faker::Internet.free_email(name: 'smith')                                            #=> "[email protected]"

Parameters:

  • name (String) (defaults to: nil)

Returns:

  • (String)


63
64
65
66
67
68
# File 'lib/faker/default/internet.rb', line 63

def free_email(name: nil)
  construct_email(
    sanitize_email_local_part(username(specifier: name)),
    fetch('internet.free_email')
  )
end

.ip_v4_addressString

Returns the IPv4 address

Examples:

Faker::Internet.ip_v4_address   #=> "97.117.128.93"

Returns:

  • (String)


316
317
318
319
# File 'lib/faker/default/internet.rb', line 316

def ip_v4_address
  [rand_in_range(0, 255), rand_in_range(0, 255),
   rand_in_range(0, 255), rand_in_range(0, 255)].join('.')
end

.ip_v4_cidrString

Returns Ipv4 address with CIDR, range from 1 to 31

Examples:

Faker::Internet.ip_v4_cidr  #=> "129.162.99.74/16"
Faker::Internet.ip_v4_cidr  #=> "129.162.99.74/24"

Returns:

  • (String)


419
420
421
# File 'lib/faker/default/internet.rb', line 419

def ip_v4_cidr
  "#{ip_v4_address}/#{rand(1..31)}"
end

.ip_v6_addressString

Returns Ipv6 address

Examples:

Faker::Internet.ip_v6_address   #=> "7754:76d4:c7aa:7646:ea68:1abb:4055:4343"

Returns:

  • (String)


430
431
432
# File 'lib/faker/default/internet.rb', line 430

def ip_v6_address
  (1..8).map { rand(65_536).to_s(16) }.join(':')
end

.ip_v6_cidrString

Returns Ipv6 address with CIDR, range between 1 to 127

Examples:

Faker::Internet.ip_v6_cidr  #=> "beca:9b99:4bb6:9712:af2f:516f:8507:96e1/99"

Returns:

  • (String)


441
442
443
# File 'lib/faker/default/internet.rb', line 441

def ip_v6_cidr
  "#{ip_v6_address}/#{rand(1..127)}"
end

.mac_address(prefix: '') ⇒ String

Returns the MAC address

Examples:

Faker::Internet.mac_address                   #=> "74:d0:c9:22:95:12"
Faker::Internet.mac_address(prefix: 'a')      #=> "0a:91:ce:24:89:3b"
Faker::Internet.mac_address(prefix: 'aa')     #=> "aa:38:a0:3e:e8:41"
Faker::Internet.mac_address(prefix: 'aa:44')  #=> "aa:44:30:88:6e:95"

Returns:

  • (String)


303
304
305
306
307
# File 'lib/faker/default/internet.rb', line 303

def mac_address(prefix: '')
  prefix_digits = prefix.split(':').map { |d| d.to_i(16) }
  address_digits = Array.new((6 - prefix_digits.size)) { rand(256) }
  (prefix_digits + address_digits).map { |d| format('%02x', d) }.join(':')
end

.password(min_length: 8, max_length: 16, mix_case: true, special_characters: false) ⇒ String

Produces a randomized string of characters suitable for passwords

Examples:

Faker::Internet.password #=> "Vg5mSvY1UeRg7"
Faker::Internet.password(min_length: 8) #=> "YfGjIk0hGzDqS0"
Faker::Internet.password(min_length: 10, max_length: 20) #=> "EoC9ShWd1hWq4vBgFw"
Faker::Internet.password(min_length: 10, max_length: 20, mix_case: true) #=> "3k5qS15aNmG"
Faker::Internet.password(min_length: 10, max_length: 20, mix_case: true, special_characters: true) #=> "*%NkOnJsH4"

Parameters:

  • min_length (Integer) (defaults to: 8)

    The minimum length of the password

  • max_length (Integer) (defaults to: 16)

    The maximum length of the password

  • mix_case (Boolean) (defaults to: true)

    Toggles if uppercased letters are allowed. If true, at least one will be added.

  • special_characters (Boolean) (defaults to: false)

    Toggles if special characters are allowed. If true, at least one will be added.

Returns:

  • (String)

Raises:

  • (ArgumentError)

Available since:

  • 2.1.3



161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
# File 'lib/faker/default/internet.rb', line 161

def password(min_length: 8, max_length: 16, mix_case: true, special_characters: false)
  raise ArgumentError, 'min_length and max_length must be greater than or equal to one' if min_length < 1 || max_length < 1
  raise ArgumentError, 'min_length must be smaller than or equal to max_length' unless min_length <= max_length

  character_types = []
  required_min_length = 0

  if mix_case
    character_types << :mix_case
    required_min_length += 2
  end

  if special_characters
    character_types << :special_characters
    required_min_length += 1
  end

  raise ArgumentError, "min_length should be at least #{required_min_length} to enable #{character_types.join(', ')} configuration" if min_length < required_min_length

  target_length = rand(min_length..max_length)

  password = []
  character_bag = []

  # use lower_chars by default and add upper_chars if mix_case
  lower_chars = self::LLetters
  password << sample(lower_chars)
  character_bag += lower_chars

  digits = ('0'..'9').to_a
  password << sample(digits)
  character_bag += digits

  if mix_case
    upper_chars = self::ULetters
    password << sample(upper_chars)
    character_bag += upper_chars
  end

  if special_characters
    special_chars = %w[! @ # $ % ^ & *]
    password << sample(special_chars)
    character_bag += special_chars
  end

  password << sample(character_bag) while password.length < target_length

  shuffle(password).join
end

.private_ip_v4_addressString

Returns the private IPv4 address

Examples:

Faker::Internet.private_ip_v4_address   #=> "127.120.80.42"

Returns:

  • (String)


328
329
330
# File 'lib/faker/default/internet.rb', line 328

def private_ip_v4_address
  sample(PRIVATE_IPV4_ADDRESS_RANGES).map { |range| rand(range) }.join('.')
end

.private_net_checkerLambda

Returns lambda to check if address passed is private or not

Examples:

Faker::Internet.private_net_checker.call("127.120.80.42")   #=> true
Faker::Internet.private_net_checker.call("148.120.80.42")   #=> false

Returns:

  • (Lambda)


376
377
378
# File 'lib/faker/default/internet.rb', line 376

def private_net_checker
  ->(addr) { private_nets_regex.any? { |net| net =~ addr } }
end

.private_nets_regexArray

Returns the private network regular expressions

Examples:

Faker::Internet.private_nets_regex  #=> [/^10\./, /^100\.(6[4-9]|[7-9]\d|1[0-1]\d|12[0-7])\./, /^127\./, /^169\.254\./, /^172\.(1[6-9]|2\d|3[0-1])\./, /^192\.0\.0\./, /^192\.168\./, /^198\.(1[8-9])\./]

Returns:

  • (Array)


355
356
357
358
359
360
361
362
363
364
365
366
# File 'lib/faker/default/internet.rb', line 355

def private_nets_regex
  [
    /^10\./,                                       # 10.0.0.0    - 10.255.255.255
    /^100\.(6[4-9]|[7-9]\d|1[0-1]\d|12[0-7])\./,   # 100.64.0.0  - 100.127.255.255
    /^127\./,                                      # 127.0.0.0   - 127.255.255.255
    /^169\.254\./,                                 # 169.254.0.0 - 169.254.255.255
    /^172\.(1[6-9]|2\d|3[0-1])\./,                 # 172.16.0.0  - 172.31.255.255
    /^192\.0\.0\./,                                # 192.0.0.0   - 192.0.0.255
    /^192\.168\./,                                 # 192.168.0.0 - 192.168.255.255
    /^198\.(1[8-9])\./                             # 198.18.0.0  - 198.19.255.255
  ]
end

.public_ip_v4_addressString

Returns the public IPv4 address

Examples:

Faker::Internet.public_ip_v4_address   #=> "127.120.80.42"

Returns:

  • (String)


339
340
341
342
343
344
345
346
# File 'lib/faker/default/internet.rb', line 339

def public_ip_v4_address
  addr = nil
  loop do
    addr = ip_v4_address
    break unless reserved_net_checker[addr]
  end
  addr
end

.reserved_net_checkerLambda

Returns lambda function to check address passed is reserved or not

Examples:

Faker::Internet.reserved_net_checker.call('192.88.99.255')   #=> true
Faker::Internet.reserved_net_checker.call('192.88.199.255')  #=> false

Returns:

  • (Lambda)


407
408
409
# File 'lib/faker/default/internet.rb', line 407

def reserved_net_checker
  ->(addr) { (private_nets_regex + reserved_nets_regex).any? { |net| net =~ addr } }
end

.reserved_nets_regexArray

Returns the reserved network regular expressions

Examples:

Faker::Internet.reserved_nets_regex   #=> [/^0\./, /^192\.0\.2\./, /^192\.88\.99\./, /^198\.51\.100\./, /^203\.0\.113\./, /^(22[4-9]|23\d)\./, /^(24\d|25[0-5])\./]

Returns:

  • (Array)


387
388
389
390
391
392
393
394
395
396
397
# File 'lib/faker/default/internet.rb', line 387

def reserved_nets_regex
  [
    /^0\./,                 # 0.0.0.0      - 0.255.255.255
    /^192\.0\.2\./,         # 192.0.2.0    - 192.0.2.255
    /^192\.88\.99\./,       # 192.88.99.0  - 192.88.99.255
    /^198\.51\.100\./,      # 198.51.100.0 - 198.51.100.255
    /^203\.0\.113\./,       # 203.0.113.0  - 203.0.113.255
    /^(22[4-9]|23\d)\./,    # 224.0.0.0    - 239.255.255.255
    /^(24\d|25[0-5])\./     # 240.0.0.0    - 255.255.255.254  and  255.255.255.255
  ]
end

.safe_email(name: nil) ⇒ String

Returns the email address with fixed domain name as ‘example’

Examples:

Faker::Internet.safe_email                                                           #=> "[email protected]"
Faker::Internet.safe_email(name: 'smith')                                            #=> "[email protected]"

Parameters:

  • name (String) (defaults to: nil)

Returns:

  • (String)


81
82
83
84
85
86
# File 'lib/faker/default/internet.rb', line 81

def safe_email(name: nil)
  construct_email(
    sanitize_email_local_part(username(specifier: name)),
    "example.#{sample(%w[org com net])}"
  )
end

.slug(words: nil, glue: nil) ⇒ String

Returns unique string in URL

Examples:

Faker::Internet.slug                                    #=> "repudiandae-sed"
Faker::Internet.slug(words: 'test, faker')              #=> "test-faker"
Faker::Internet.slug(words: 'test. faker')              #=> "test-faker"
Faker::Internet.slug(words: 'test. faker', glue: '$')   #=> "test$faker"

Parameters:

  • words (String) (defaults to: nil)

    Comma or period separated words list

  • glue (String) (defaults to: nil)

    Separator to add between words passed, default used are ‘-’ or ‘_’

Returns:

  • (String)


476
477
478
479
480
481
# File 'lib/faker/default/internet.rb', line 476

def slug(words: nil, glue: nil)
  glue ||= sample(%w[- _])
  return words.delete(',.').gsub(' ', glue).downcase unless words.nil?

  sample(translate('faker.internet.slug'), 2).join(glue)
end

.url(host: domain_name, path: "/#{username}", scheme: 'http') ⇒ String

Returns URL

Examples:

Faker::Internet.url                                                           #=> "http://treutel.test/demarcus"
Faker::Internet.url(host: 'faker')                                            #=> "http://faker/shad"
Faker::Internet.url(host: 'faker', path: '/docs')                             #=> "http://faker/docs"
Faker::Internet.url(host: 'faker', path: '/docs', scheme: 'https')            #=> "https://faker/docs"

Parameters:

  • host (String) (defaults to: domain_name)
  • path (String) (defaults to: "/#{username}")
  • scheme (String) (defaults to: 'http')

Returns:

  • (String)


459
460
461
# File 'lib/faker/default/internet.rb', line 459

def url(host: domain_name, path: "/#{username}", scheme: 'http')
  "#{scheme}://#{host}#{path}"
end

.user(*args) ⇒ hash

Produces a randomized hash of internet user details

Examples:

Faker::Internet.user #=> { username: 'alexie', email: '[email protected]' }
Faker::Internet.user('username', 'email', 'password') #=> { username: 'alexie', email: '[email protected]', password: 'DtEf9P8wS31iMyC' }

Returns:

  • (hash)

Available since:

  • next



584
585
586
587
588
589
# File 'lib/faker/default/internet.rb', line 584

def user(*args)
  user_hash = {}
  args = %w[username email] if args.empty?
  args.each { |arg| user_hash[:"#{arg}"] = send(arg) }
  user_hash
end

.user_agent(vendor: nil) ⇒ String

Generates the random browser identifier

Examples:

Faker::Internet.user_agent                    #=> "Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2228.0 Safari/537.36"
Faker::Internet.user_agent(vendor: 'chrome')  #=> "Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2228.0 Safari/537.36"
Faker::Internet.user_agent(vendor: 'safari')  #=> "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_3) AppleWebKit/537.75.14 (KHTML, like Gecko) Version/7.0.3 Safari/7046A194A"
Faker::Internet.user_agent(vendor: 'faker')   #=> "Mozilla/5.0 (Windows; U; Win 9x 4.90; SG; rv:1.9.2.4) Gecko/20101104 Netscape/9.1.0285"

Parameters:

  • vendor (String) (defaults to: nil)

    Name of vendor, supported vendors are aol, chrome, firefox, internet_explorer, netscape, opera, safari

Returns:

  • (String)


506
507
508
509
510
# File 'lib/faker/default/internet.rb', line 506

def user_agent(vendor: nil)
  agent_hash = translate('faker.internet.user_agent')
  agents = vendor.respond_to?(:to_sym) && agent_hash[vendor.to_sym] || agent_hash[sample(agent_hash.keys)]
  sample(agents)
end

.username(specifier: nil, separators: %w[. _]) ⇒ String Also known as: user_name

Returns the username

Examples:

Faker::Internet.username(specifier: 10)                     #=> "lulu.goodwin"
Faker::Internet.username(specifier: 5..10)                  #=> "morris"
Faker::Internet.username(specifier: 5..10)                  #=> "berryberry"
Faker::Internet.username(specifier: 20, separators: ['-'])  #=> "nikki_sawaynnikki_saway"

Parameters:

  • specifier (Integer, Range, String) (defaults to: nil)

    When int value passed it returns the username longer than specifier. Max value can be 10^6

  • separators (Array) (defaults to: %w[. _])

Returns:

  • (String)


102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
# File 'lib/faker/default/internet.rb', line 102

def username(specifier: nil, separators: %w[. _])
  with_locale(:en) do
    return shuffle(specifier.scan(/[[:word:]]+/)).join(sample(separators)).downcase if specifier.respond_to?(:scan)

    case specifier
    when Integer
      # If specifier is Integer and has large value, Argument error exception is raised to overcome memory full error
      raise ArgumentError, 'Given argument is too large' if specifier > 10**6

      tries = 0 # Don't try forever in case we get something like 1_000_000.
      result = nil
      loop do
        result = username(specifier: nil, separators: separators)
        tries += 1
        break unless result.length < specifier && tries < 7
      end
      return result * (specifier / result.length + 1) if specifier.positive?
    when Range
      tries = 0
      result = nil
      loop do
        result = username(specifier: specifier.min, separators: separators)
        tries += 1
        break unless !specifier.include?(result.length) && tries < 7
      end
      return result[0...specifier.max]
    end

    sample([
             Char.prepare(Name.first_name),
             [Name.first_name, Name.last_name].map do |name|
               Char.prepare(name)
             end.join(sample(separators))
           ])
  end
end

.uuidString

Generated universally unique identifier

Examples:

Faker::Internet.uuid  #=> "8a6cdd40-6d78-4fdb-912b-190e3057197f"

Returns:

  • (String)


536
537
538
539
540
541
542
# File 'lib/faker/default/internet.rb', line 536

def uuid
  # borrowed from: https://github.com/ruby/ruby/blob/d48783bb0236db505fe1205d1d9822309de53a36/lib/securerandom.rb#L250
  ary = Faker::Config.random.bytes(16).unpack('NnnnnN')
  ary[2] = (ary[2] & 0x0fff) | 0x4000
  ary[3] = (ary[3] & 0x3fff) | 0x8000
  '%08x-%04x-%04x-%04x-%04x%08x' % ary # rubocop:disable Style/FormatString
end