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:

  • (String)

Available since:

  • 2.11.0


556
557
558
559
560
561
562
563
564
565
566
# File 'lib/faker/default/internet.rb', line 556

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_tokenObject

Generates random token

@return

Examples:

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

498
499
500
# File 'lib/faker/default/internet.rb', line 498

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)

220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
# File 'lib/faker/default/internet.rb', line 220

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_suffixString

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

Examples:

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

Returns:

  • (String)

279
280
281
# File 'lib/faker/default/internet.rb', line 279

def domain_suffix
  fetch('internet.domain_suffix')
end

.domain_wordString

Returns the domain word for internet

Examples:

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

Returns:

  • (String)

268
269
270
# File 'lib/faker/default/internet.rb', line 268

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)

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

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)

253
254
255
256
257
258
259
# File 'lib/faker/default/internet.rb', line 253

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

58
59
60
61
62
63
64
65
66
67
# File 'lib/faker/default/internet.rb', line 58

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_addressString

Returns the IPv4 address

Examples:

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

Returns:

  • (String)

310
311
312
313
# File 'lib/faker/default/internet.rb', line 310

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)

413
414
415
# File 'lib/faker/default/internet.rb', line 413

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)

424
425
426
# File 'lib/faker/default/internet.rb', line 424

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)

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

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)

293
294
295
296
297
298
299
300
301
# File 'lib/faker/default/internet.rb', line 293

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


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

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_addressString

Returns the private IPv4 address

Examples:

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

Returns:

  • (String)

322
323
324
# File 'lib/faker/default/internet.rb', line 322

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)

370
371
372
# File 'lib/faker/default/internet.rb', line 370

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)

349
350
351
352
353
354
355
356
357
358
359
360
# File 'lib/faker/default/internet.rb', line 349

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)

333
334
335
336
337
338
339
340
# File 'lib/faker/default/internet.rb', line 333

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)

401
402
403
# File 'lib/faker/default/internet.rb', line 401

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)

381
382
383
384
385
386
387
388
389
390
391
# File 'lib/faker/default/internet.rb', line 381

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)

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

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)

479
480
481
482
483
484
485
486
487
488
489
# File 'lib/faker/default/internet.rb', line 479

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[- _])
  return words.delete(',.').gsub(' ', glue).downcase unless words.nil?

  sample(translate('faker.internet.slug'), 2).join(glue)
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)

455
456
457
458
459
460
461
462
463
# File 'lib/faker/default/internet.rb', line 455

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(*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


579
580
581
582
583
584
# File 'lib/faker/default/internet.rb', line 579

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

514
515
516
517
518
519
520
521
522
# File 'lib/faker/default/internet.rb', line 514

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

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)

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
138
139
140
141
142
143
# File 'lib/faker/default/internet.rb', line 103

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

.uuidString

Generated universally unique identifier

Examples:

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

Returns:

  • (String)

531
532
533
534
535
536
537
# File 'lib/faker/default/internet.rb', line 531

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