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



519
520
521
522
523
524
525
526
527
528
529
 
# File 'lib/faker/default/internet.rb', line 519

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:



481
482
483
484
485
 
# File 'lib/faker/default/internet.rb', line 481

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_token ⇒ Object

Generates random token

@return

Examples:

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


448
449
450
 
# File 'lib/faker/default/internet.rb', line 448

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                                       #=> "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:



196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
 
# File 'lib/faker/default/internet.rb', line 196

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

Examples:

Faker::Internet.domain_suffix   #=> "com"
Faker::Internet.domain_suffix   #=> "biz"

Returns:



247
248
249
 
# File 'lib/faker/default/internet.rb', line 247

def domain_suffix
  fetch('internet.domain_suffix')
end

.domain_word ⇒ String

Returns the domain word for internet

Examples:

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

Returns:



236
237
238
 
# File 'lib/faker/default/internet.rb', line 236

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                                                           #=> "samsmith@faker.com"
Faker::Internet.email(name: 'smith')                                            #=> "smith@faker.com"
Faker::Internet.email(name: 'sam smith', separators: ['-'])                     #=> "sam-smith@faker.com"
Faker::Internet.email(name: 'sam smith', separators: ['-'], domain: 'gmail')    #=> "sam-smith@gmail.com"

Parameters:

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

Returns:



32
33
34
35
36
37
38
39
40
41
 
# File 'lib/faker/default/internet.rb', line 32

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)
  construct_email(sanitized_local_part, domain_name(domain: 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:



225
226
227
 
# File 'lib/faker/default/internet.rb', line 225

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                                                           #=> "samsmith@gmail.com"
Faker::Internet.free_email(name: 'smith')                                            #=> "smith@yahoo.com"

Parameters:

  • name (String) (defaults to: nil)

Returns:



53
54
55
56
57
58
 
# File 'lib/faker/default/internet.rb', line 53

def free_email(name: nil)
  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:



274
275
276
277
 
# File 'lib/faker/default/internet.rb', line 274

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:



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

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:



388
389
390
 
# File 'lib/faker/default/internet.rb', line 388

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:



399
400
401
 
# File 'lib/faker/default/internet.rb', line 399

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:



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

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:

Raises:

  • (ArgumentError) 


149
150
151
152
153
154
155
156
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
 
# File 'lib/faker/default/internet.rb', line 149

def password(min_length: 8, max_length: 16, mix_case: true, special_characters: false)
  raise ArgumentError, 'Password of length 1 can not have both mixed case and special characters' if min_length <= 1 && mix_case && special_characters

  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[rand(temp.size - 1)] = Lorem.characters(number: 1, min_alpha: 1).upcase if mix_case && special_characters && !temp.match(/[A-z]+/)

  temp
end

.private_ip_v4_address ⇒ String

Returns the private IPv4 address

Examples:

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

Returns:



286
287
288
 
# File 'lib/faker/default/internet.rb', line 286

def private_ip_v4_address
  sample(PRIVATE_IPV4_ADDRESS_RANGES).map { |range| rand(range) }.join('.')
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) 


334
335
336
 
# File 'lib/faker/default/internet.rb', line 334

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) 


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

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:



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

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


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

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) 


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

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                                                           #=> "samsmith@example.com"
Faker::Internet.safe_email(name: 'smith')                                            #=> "smith@example.net"

Parameters:

  • name (String) (defaults to: nil)

Returns:



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

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:



434
435
436
437
438
439
 
# File 'lib/faker/default/internet.rb', line 434

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://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:



417
418
419
 
# File 'lib/faker/default/internet.rb', line 417

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: 'alexie@example.net' }
Faker::Internet.user('username', 'email', 'password') #=> { username: 'alexie', email: 'alexie@example.net', password: 'DtEf9P8wS31iMyC' }

Returns:

  • (hash) 


542
543
544
545
546
547
 
# File 'lib/faker/default/internet.rb', line 542

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:



464
465
466
467
468
 
# File 'lib/faker/default/internet.rb', line 464

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:



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

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

.uuid ⇒ String

Generated universally unique identifier

Examples:

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

Returns:



494
495
496
497
498
499
500
 
# File 'lib/faker/default/internet.rb', line 494

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