Class: Faker::Internet

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

Constant Summary

Constants inherited from Base

Base::Letters, Base::Numbers, Base::ULetters

Class Method Summary collapse

Methods inherited from Base

bothify, fetch, fetch_all, flexible, letterify, method_missing, numerify, parse, rand_in_range, regexify, translate, unique, with_locale

Class Method Details

.device_token ⇒ Object 



155
156
157
 
# File 'lib/faker/internet.rb', line 155

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

.domain_name ⇒ Object 



73
74
75
 
# File 'lib/faker/internet.rb', line 73

def domain_name
  with_locale(:en) { [Char.prepare(domain_word), domain_suffix].join('.') }
end

.domain_suffix ⇒ Object 



88
89
90
 
# File 'lib/faker/internet.rb', line 88

def domain_suffix
  fetch('internet.domain_suffix')
end

.domain_word ⇒ Object 



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

def domain_word
  if %w(uk).include? Config.locale
    return Char.prepare Company.name.split(' ')[1]
  end
  Char.prepare Company.name.split(' ').first
end

.email(name = nil) ⇒ Object 



5
6
7
 
# File 'lib/faker/internet.rb', line 5

def email(name = nil)
  [user_name(name), domain_name].join('@')
end

.fix_umlauts(string) ⇒ Object 



77
78
79
 
# File 'lib/faker/internet.rb', line 77

def fix_umlauts(string)
  Char.fix_umlauts string
end

.free_email(name = nil) ⇒ Object 



9
10
11
 
# File 'lib/faker/internet.rb', line 9

def free_email(name = nil)
  [user_name(name), fetch('internet.free_email')].join('@')
end

.ip_v4_address ⇒ Object 



98
99
100
 
# File 'lib/faker/internet.rb', line 98

def ip_v4_address
  (1..4).map { rand(2..254) }.join('.')
end

.ip_v4_cidr ⇒ Object 



134
135
136
 
# File 'lib/faker/internet.rb', line 134

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

.ip_v6_address ⇒ Object 



138
139
140
 
# File 'lib/faker/internet.rb', line 138

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

.ip_v6_cidr ⇒ Object 



142
143
144
 
# File 'lib/faker/internet.rb', line 142

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

.mac_address(prefix = '') ⇒ Object 



92
93
94
95
96
 
# File 'lib/faker/internet.rb', line 92

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

.password(min_length = 8, max_length = 16, mix_case = true, special_chars = false) ⇒ Object 



49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
 
# File 'lib/faker/internet.rb', line 49

def password(min_length = 8, max_length = 16, mix_case = true, special_chars = false)
  temp = Lorem.characters(min_length)
  diff_length = max_length - min_length
  if diff_length > 0
    diff_rand = rand(diff_length + 1)
    temp += Lorem.characters(diff_rand)
  end

  if mix_case
    temp.chars.each_with_index do |char, index|
      temp[index] = char.upcase if index % 2 == 0
    end
  end

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

  return temp
end

.private_ip_v4_address ⇒ Object 



102
103
104
105
106
107
108
109
 
# File 'lib/faker/internet.rb', line 102

def private_ip_v4_address
  is_private = private_net_checker
  addr = nil
  begin
    addr = ip_v4_address
  end while !is_private[addr]
  addr
end

.private_net_checker ⇒ Object 



130
131
132
 
# File 'lib/faker/internet.rb', line 130

def private_net_checker
  lambda { |addr| private_nets_regex.any? { |net| net =~ addr } }
end

.private_nets_regex ⇒ Object 



120
121
122
123
124
125
126
127
128
 
# File 'lib/faker/internet.rb', line 120

def private_nets_regex
  [
    /^10\./,
    /^127\./,
    /^169\.254\./,
    /^172\.(16|17|18|19|2\d|30|31)\./,
    /^192\.168\./
  ]
end

.public_ip_v4_address ⇒ Object 



111
112
113
114
115
116
117
118
 
# File 'lib/faker/internet.rb', line 111

def public_ip_v4_address
  is_private = private_net_checker
  addr = nil
  begin
    addr = ip_v4_address
  end while is_private[addr]
  addr
end

.safe_email(name = nil) ⇒ Object 



13
14
15
 
# File 'lib/faker/internet.rb', line 13

def safe_email(name = nil)
  [user_name(name), 'example.'+ %w[org com net].shuffle.first].join('@')
end

.slug(words = nil, glue = nil) ⇒ Object 



150
151
152
153
 
# File 'lib/faker/internet.rb', line 150

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

.url(host = domain_name, path = "/#{user_name}", scheme = 'http') ⇒ Object 



146
147
148
 
# File 'lib/faker/internet.rb', line 146

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

.user_name(specifier = nil, separators = %w(. _)) ⇒ Object 



17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
 
# File 'lib/faker/internet.rb', line 17

def user_name(specifier = nil, separators = %w(. _))
  with_locale(:en) do
    if specifier.kind_of? String
      return specifier.scan(/\w+/).shuffle.join(separators.sample).downcase
    elsif specifier.kind_of? 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.
      begin
        result = user_name nil, separators
        tries += 1
      end while result.length < specifier and tries < 7
      result = result * (specifier/result.length + 1) if specifier > 0
      return result
    elsif specifier.kind_of? Range
      tries = 0
      begin
        result = user_name specifier.min, separators
        tries += 1
      end while not specifier.include? result.length and tries < 7
      return result[0...specifier.max]
    end

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