Class: Faker::Internet

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

Defined Under Namespace

Classes: HTTP

Constant Summary

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, 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


550
551
552
553
554
555
556
557
558
559
560
 
# File 'lib/faker/default/internet.rb', line 550

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

.device_token ⇒ Object

Generates random token

@return

Examples:

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

492
493
494
 
# File 'lib/faker/default/internet.rb', line 492

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

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

Returns the domain name

Examples:

Faker::Internet.domain_name                                       #=> "test.net"
Faker::Internet.domain_name(subdomain: true)                      #=> "test.faker.io"
Faker::Internet.domain_name(subdomain: true, domain: 'example')   #=> "faker.example.com"
Faker::Internet.domain_name(domain: 'faker')                      #=> "faker.org"

Parameters:

  • subdomain (Bool) (defaults to: false) —

    If true passed adds a subdomain in response

  • domain (String) (defaults to: nil)

Returns:

  • (String) 

208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
 
# File 'lib/faker/default/internet.rb', line 208

def domain_name(legacy_subdomain = NOT_GIVEN, subdomain: false, domain: nil)
  warn_for_deprecated_arguments do |keywords|
    keywords << :subdomain if legacy_subdomain != NOT_GIVEN
  end

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

.domain_suffix ⇒ String

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

Returns:

  • (String) 

270
271
272
 
# File 'lib/faker/default/internet.rb', line 270

def domain_suffix
  fetch('internet.domain_suffix')
end

.domain_word ⇒ String

Returns the domain word for internet

Examples:

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

Returns:

  • (String) 

259
260
261
 
# File 'lib/faker/default/internet.rb', line 259

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

.email(legacy_name = NOT_GIVEN, legacy_separators = NOT_GIVEN, 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: 'gmail')    #=> "[email protected]"

Parameters:

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

Returns:

  • (String) 

20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 
# File 'lib/faker/default/internet.rb', line 20

def email(legacy_name = NOT_GIVEN, legacy_separators = NOT_GIVEN, name: nil, separators: nil, domain: nil)
  warn_for_deprecated_arguments do |keywords|
    keywords << :name if legacy_name != NOT_GIVEN
    keywords << :separators if legacy_separators != NOT_GIVEN
  end

  local_part = if separators
                 username(specifier: name, separators: separators)
               else
                 username(specifier: name)
               end

  sanitized_local_part = sanitize_email_local_part(local_part)
  construct_email(sanitized_local_part, domain_name(domain: domain))
end

.fix_umlauts(legacy_string = NOT_GIVEN, 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) 

243
244
245
246
247
248
249
 
# File 'lib/faker/default/internet.rb', line 243

def fix_umlauts(legacy_string = NOT_GIVEN, string: '')
  warn_for_deprecated_arguments do |keywords|
    keywords << :string if legacy_string != NOT_GIVEN
  end

  Char.fix_umlauts(string)
end

.free_email(legacy_name = NOT_GIVEN, name: nil) ⇒ String

Returns the email address with doamin 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) 

46
47
48
49
50
51
52
53
54
55
 
# File 'lib/faker/default/internet.rb', line 46

def free_email(legacy_name = NOT_GIVEN, name: nil)
  warn_for_deprecated_arguments do |keywords|
    keywords << :name if legacy_name != NOT_GIVEN
  end

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

.ip_v4_address ⇒ String

Returns the IPv4 address

Examples:

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

Returns:

  • (String) 

301
302
303
304
 
# File 'lib/faker/default/internet.rb', line 301

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_cidr ⇒ String

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) 

409
410
411
 
# File 'lib/faker/default/internet.rb', line 409

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

.ip_v6_address ⇒ String

Returns Ipv6 address

Examples:

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

Returns:

  • (String) 

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

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

.ip_v6_cidr ⇒ String

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) 

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

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

.mac_address(legacy_prefix = NOT_GIVEN, 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) 

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

def mac_address(legacy_prefix = NOT_GIVEN, prefix: '')
  warn_for_deprecated_arguments do |keywords|
    keywords << :prefix if legacy_prefix != NOT_GIVEN
  end

  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(legacy_min_length = NOT_GIVEN, legacy_max_length = NOT_GIVEN, legacy_mix_case = NOT_GIVEN, legacy_special_characters = NOT_GIVEN, 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)

Available since:

  • 2.1.3


157
158
159
160
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
 
# File 'lib/faker/default/internet.rb', line 157

def password(legacy_min_length = NOT_GIVEN, legacy_max_length = NOT_GIVEN, legacy_mix_case = NOT_GIVEN, legacy_special_characters = NOT_GIVEN, min_length: 8, max_length: 16, mix_case: true, special_characters: false)
  warn_for_deprecated_arguments do |keywords|
    keywords << :min_length if legacy_min_length != NOT_GIVEN
    keywords << :max_length if legacy_max_length != NOT_GIVEN
    keywords << :mix_case if legacy_mix_case != NOT_GIVEN
    keywords << :special_characters if legacy_special_characters != NOT_GIVEN
  end

  min_alpha = mix_case && min_length > 1 ? 2 : 0
  temp = Lorem.characters(number: min_length, min_alpha: min_alpha)
  diff_length = max_length - min_length

  if diff_length.positive?
    diff_rand = rand(diff_length + 1)
    temp += Lorem.characters(number: diff_rand)
  end

  if mix_case
    alpha_count = 0
    temp.chars.each_with_index do |char, index|
      if char =~ /[[:alpha:]]/
        temp[index] = char.upcase if alpha_count.even?
        alpha_count += 1
      end
    end
  end

  if special_characters
    chars = %w[! @ # $ % ^ & *]
    rand(1..min_length).times do |i|
      temp[i] = chars[rand(chars.length)]
    end
  end

  temp
end

.private_ip_v4_address ⇒ String

Returns the private IPv4 address

Examples:

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

Returns:

  • (String) 

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

def private_ip_v4_address
  addr = nil
  loop do
    addr = ip_v4_address
    break if private_net_checker[addr]
  end
  addr
end

.private_net_checker ⇒ Lambda

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) 

366
367
368
 
# File 'lib/faker/default/internet.rb', line 366

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

.private_nets_regex ⇒ Array

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) 

345
346
347
348
349
350
351
352
353
354
355
356
 
# File 'lib/faker/default/internet.rb', line 345

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_address ⇒ String

Returns the public IPv4 address

Examples:

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

Returns:

  • (String) 

329
330
331
332
333
334
335
336
 
# File 'lib/faker/default/internet.rb', line 329

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

.reserved_net_checker ⇒ Lambda

Returns lambda function to check address passed is reserverd 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) 

397
398
399
 
# File 'lib/faker/default/internet.rb', line 397

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

.reserved_nets_regex ⇒ Array

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) 

377
378
379
380
381
382
383
384
385
386
387
 
# File 'lib/faker/default/internet.rb', line 377

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(legacy_name = NOT_GIVEN, 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) 

67
68
69
70
71
72
73
74
75
76
 
# File 'lib/faker/default/internet.rb', line 67

def safe_email(legacy_name = NOT_GIVEN, name: nil)
  warn_for_deprecated_arguments do |keywords|
    keywords << :name if legacy_name != NOT_GIVEN
  end

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

.slug(legacy_words = NOT_GIVEN, legacy_glue = NOT_GIVEN, 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) 

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

def slug(legacy_words = NOT_GIVEN, legacy_glue = NOT_GIVEN, words: nil, glue: nil)
  warn_for_deprecated_arguments do |keywords|
    keywords << :words if legacy_words != NOT_GIVEN
    keywords << :glue if legacy_glue != NOT_GIVEN
  end

  glue ||= sample(%w[- _])
  (words || Faker::Lorem.words(number: 2).join(' ')).delete(',.').gsub(' ', glue).downcase
end

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

Returns URL

Examples:

Faker::Internet.url                                                           #=> "http://sipes-okon.com/hung.macejkovic"
Faker::Internet.url(host: 'faker')                                            #=> "http://faker/shad"
Faker::Internet.url(host: 'faker', path: '/fake_test_path')                   #=> "http://faker/fake_test_path"
Faker::Internet.url(host: 'faker', path: '/fake_test_path', scheme: 'https')  #=> "https://faker/fake_test_path"

Parameters:

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

Returns:

  • (String) 

451
452
453
454
455
456
457
458
459
 
# File 'lib/faker/default/internet.rb', line 451

def url(legacy_host = NOT_GIVEN, legacy_path = NOT_GIVEN, legacy_scheme = NOT_GIVEN, host: domain_name, path: "/#{username}", scheme: 'http')
  warn_for_deprecated_arguments do |keywords|
    keywords << :host if legacy_host != NOT_GIVEN
    keywords << :path if legacy_path != NOT_GIVEN
    keywords << :scheme if legacy_scheme != NOT_GIVEN
  end

  "#{scheme}://#{host}#{path}"
end

.user_agent(legacy_vendor = NOT_GIVEN, 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) 

508
509
510
511
512
513
514
515
516
 
# File 'lib/faker/default/internet.rb', line 508

def user_agent(legacy_vendor = NOT_GIVEN, vendor: nil)
  warn_for_deprecated_arguments do |keywords|
    keywords << :vendor if legacy_vendor != NOT_GIVEN
  end

  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(legacy_specifier = NOT_GIVEN, legacy_separators = NOT_GIVEN, specifier: nil, separators: %w[. _]) ⇒ String Also known as: user_name

Returns the username

Parameters:

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

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

  • separator (Array)

Returns:

  • (String) 

91
92
93
94
95
96
97
98
99
100
101
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
 
# File 'lib/faker/default/internet.rb', line 91

def username(legacy_specifier = NOT_GIVEN, legacy_separators = NOT_GIVEN, specifier: nil, separators: %w[. _])
  warn_for_deprecated_arguments do |keywords|
    keywords << :specifier if legacy_specifier != NOT_GIVEN
    keywords << :separators if legacy_separators != NOT_GIVEN
  end

  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

.uuid ⇒ String

Generated universally unique identifier

Examples:

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

Returns:

  • (String) 

525
526
527
528
529
530
531
 
# File 'lib/faker/default/internet.rb', line 525

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