ffaker 1.15.0 → 1.16.0

data/lib/ffaker/phone_number_se.rb

@@ -0,0 +1,111 @@
+# encoding: utf-8
+
+module Faker
+
+  # Format for swedish numbers, from here
+  # from http://sv.wikipedia.org/wiki/Telefonnummer
+  #
+  # All area codes are from this list
+  # http://sv.wikipedia.org/wiki/Lista_%C3%B6ver_svenska_riktnummer
+  #
+  # - Length 9
+  #   08-xxx xxx xx, 0xx-xxx xx xx, 0xxx-xx xx xx
+  # - Length 8
+  #   08-xxx xx xx, 0xx-xx xx xx, 0xxx-xxx xx
+  # - Length 7
+  #   08-xx xx xx, 0xx-xxx xx
+  #
+  module PhoneNumberSE
+    extend ModuleUtils
+    extend self
+
+    def phone_number
+      case rand(2)
+      when 0 then home_work_phone_number
+      when 1 then mobile_phone_number
+      end
+    end
+
+    def home_work_phone_number
+      Faker.numerify("0#{phone_number_format}")
+    end
+
+    def mobile_phone_number
+      Faker.numerify("0#{mobile_phone_number_format}")
+    end
+
+    def international_phone_number
+      case rand(2)
+      when 0 then international_mobile_phone_number
+      when 1 then international_home_work_phone_number
+      end
+    end
+
+    def country_prefix
+      COUNTRY_PREFIX.rand
+    end
+
+    def international_mobile_phone_number
+      Faker.numerify("#{country_prefix} (0)#{mobile_phone_number_format}")
+    end
+
+    def international_home_work_phone_number
+      Faker.numerify("#{country_prefix} (0)#{phone_number_format}")
+    end
+
+    def area_prefix
+      PHONE_PREFIX.rand
+    end
+
+    def phone_number_format
+      prefix = area_prefix
+      case prefix.length
+        when 1 then PHONE_FORMAT_PREFIX_2.rand
+        when 2 then PHONE_FORMAT_PREFIX_3.rand
+        when 3 then PHONE_FORMAT_PREFIX_4.rand
+      end % prefix
+    end
+
+    def mobile_prefix
+      MOBILE_PHONE_PREFIX.rand
+    end
+
+    def mobile_phone_number_format
+      MOBILE_PHONE_FORMAT.rand % mobile_prefix
+    end
+
+    PHONE_FORMAT_PREFIX_2 = k ["%s-### ### ##",
+                               "%s-### ## ##",
+                               "%s-## ## ##"]
+    PHONE_FORMAT_PREFIX_3 = k ["%s-### ## ##",
+                               "%s-## ## ##",
+                               "%s-## ###"]
+    PHONE_FORMAT_PREFIX_4 = k ["%s-## ## ##",
+                               "%s-### ##"]
+
+    MOBILE_PHONE_FORMAT = k ["%s#-## ## ##", "%s#-######"]
+    COUNTRY_PREFIX = k ["+46", "0046"]
+    MOBILE_PHONE_PREFIX = k %w(70 72 73 76 74)
+
+    PHONE_PREFIX = k %w(8 11 120 121 122 123 125 13 140 141 142 143 144 150 151
+                        152 155 156 157 158 159 16 171 173 174 175 176 18 19 21
+                        220 221 222 223 224 225 226 227 23 240 241 243 246 247
+                        248 250 251 253 258 26 270 271 278 280 281 290 291 292
+                        293 294 295 297 300 301 302 303 304 31 320 321 322 325
+                        33 340 345 346 35 36 370 371 372 380 381 382 383 390
+                        392 393 40 410 411 413 414 415 416 417 418 42 430 431
+                        433 435 44 451 454 455 456 457 459 46 470 471 472 474
+                        476 477 478 479 480 481 485 486 490 491 492 493 494 495
+                        496 498 499 500 501 502 503 504 505 506 510 511 512 513
+                        514 515 520 521 522 523 524 525 526 528 530 531 532 533
+                        534 54 550 551 552 553 554 555 560 563 564 565 570 571
+                        573 580 581 582 583 584 585 586 587 589 590 591 60 611
+                        612 613 620 621 622 623 624 63 640 642 643 644 645 647
+                        650 651 652 653 657 660 661 662 663 670 671 672 680 682
+                        684 687 690 691 692 693 695 696 8 90 910 911 912 913
+                        914 915 916 918 920 921 922 923 924 925 926 927 928 929
+                        930 932 933 934 935 940 941 942 943 950 951 952 953 954
+                        960 961 970 971 973 975 976 977 978 980 981)
+
+  end
+end

data/lib/ffaker/ssn.rb

@@ -0,0 +1,15 @@
+module Faker
+  module SSN
+    extend ModuleUtils
+    extend self
+
+    # The Social Security number is a nine-digit number in the format
+    # "AAA-GG-SSSS". More info here:
+    #
+    # http://en.wikipedia.org/wiki/Social_Security_number
+    #
+    def ssn
+      Faker.numerify('###-##-####')
+    end
+  end
+end

data/lib/ffaker/ssn_se.rb

@@ -0,0 +1,111 @@
+# encoding: utf-8
+require 'date'
+
+module Faker
+
+  # The Social Security number is a 12-digit number in the format:
+  # "YYYYDDMM-XXXX'
+  #
+  # http://sv.wikipedia.org/wiki/Personnummer_i_Sverige
+  #
+  # The 4 last digits (XXXX) are generated based on what region the person are
+  # born # in, the gender and the last one is a check digit using the luhn
+  # algorithm.
+  #
+  # http://en.wikipedia.org/wiki/Luhn_algorithm
+  #
+  # Usage:
+  # ssn(from: Time.local(1980, 2, 28),
+  #     to: Time.local(2000, 2, 28),
+  #     gender: :male)
+  #
+  module SSNSE
+    extend ModuleUtils
+    extend self
+
+    def ssn(opts = {})
+      from   = opts[:from]   || ::Time.local(1940, 1, 1)
+      to     = opts[:to]     || ::Time.now
+      gender = opts[:gender] || genders.sample
+
+      raise_error_on_bad_arguments(from, to, gender)
+
+      generate_ssn(from, to, gender)
+    end
+
+    private
+
+    def generate_ssn(from, to, gender)
+      birth_date = random_birth_time_between(from, to)
+      birth_date_str = birth_date.strftime("%Y%m%d")      # "19800228"
+      region = get_random_region_for(gender)              # "413"
+      ssn_without_check_digit = birth_date_str + region   # "19800228413"
+      check_digit = luhn_check(ssn_without_check_digit)   # "9"
+      ssn_without_check_digit + check_digit               # "198002284139"
+    end
+
+    def raise_error_on_bad_arguments(from, to, gender)
+      raise ArgumentError, "Invalid from argument: from" unless to.is_a? ::Time
+      raise ArgumentError, "Invalid from argument: from" unless from.is_a? ::Time
+      raise ArgumentError, "Invalid argument: from > to" if from > to
+      raise ArgumentError, "Invalid argument: gender" unless genders.include?(gender)
+    end
+
+    def genders
+      # XXX Don't like this def.
+      [:female, :male]
+    end
+
+    def random_birth_time_between(from=::Time.local(1940, 1, 1), to=::Time.now)
+      ::Time.at(from + rand * (to.to_f - from.to_f))
+    end
+
+    def get_random_region_for(gender)
+      region_number = case gender
+        when :female then get_random_region_even
+        when :male then get_random_region_odd
+      end
+      three_character_string(region_number)
+    end
+
+    def get_random_region_even
+      (0..998).step(2).to_a.sample
+    end
+
+    def get_random_region_odd
+      get_random_region_even + 1
+    end
+
+    def three_character_string(number)
+      "%03d" % number
+    end
+
+    # http://en.wikipedia.org/wiki/Luhn_algorithm
+    def luhn_check(number)
+      multiplications = []
+
+      number.split(//).each_with_index do |digit, i|
+        if i % 2 == 0
+          multiplications << digit.to_i * 2
+        else
+          multiplications << digit.to_i
+        end
+      end
+
+      sum = 0
+      multiplications.each do |num|
+        num.to_s.each_byte do |character|
+          sum += character.chr.to_i
+        end
+      end
+
+      if sum % 10 == 0
+        control_digit = 0
+      else
+        control_digit = (sum / 10 + 1) * 10 - sum
+      end
+
+      control_digit.to_s
+    end
+  end
+end

data/lib/ffaker/string.rb

@@ -0,0 +1,90 @@
+module Faker
+  module String
+    extend ModuleUtils
+    extend self
+
+    BACKSLASH = '\\'
+
+    LOWERS     = k(('a'..'z').to_a)
+    UPPERS     = k(('A'..'Z').to_a)
+    LETTERS    = k(LOWERS + UPPERS)
+    NUMBERS    = k(('0'..'9').to_a)
+    WORD_CHARS = k(LETTERS + NUMBERS + ['_'])
+    SPACES     = k([" ", "\t"])
+    ESCAPEABLE_CHARS = '\\', '/', '.', '(', ')', '[', ']', '{', '}'
+
+    def from_regexp(exp)
+      result = ''
+      @last_token = nil
+
+      # Drop surrounding /'s and split into characters
+      tokens = exp.inspect[1...-1].split(//)
+      until tokens.empty?
+        result << process_token(tokens)
+      end
+
+      result
+    end
+
+  private
+
+    def join_escapes(tokens)
+      result = []
+      while tokens.any?
+        token = tokens.shift
+        token << tokens.shift if token == BACKSLASH
+        result << token
+      end
+      result
+    end
+
+    def process_token(tokens)
+      return '' if tokens.empty?
+
+      token = tokens.shift
+
+      case token
+      when '?' then
+        # TODO: Let ? generate nothong
+        return '' # We already printed its target
+      when '+' then
+        tokens.unshift(token) if rand(2) == 1 # Leave the `+` on to run again
+        return process_token(@last_token) # Run the last one at least once
+      when '*' then
+        tokens.unshift(token) if rand(2) == 1 # Leave the `*` on to run again
+        return '' if rand(2) == 1 # Or maybe do nothing
+        return process_token(@last_token) # Else run the last one again
+      end
+
+      generate_token token, tokens
+    end
+
+    def generate_token(token, tokens)
+      case token
+      when /\w/ then
+        @last_token = [token]
+        token
+      when BACKSLASH then
+        token = tokens.shift
+        @last_token = ['\\', token]
+        special(token)
+      when '[' then
+        set = []
+        while (ch = tokens.shift) != ']'
+          set << ch
+        end
+        @last_token = ['['] + set + [']']
+        process_token([ArrayUtils.rand(join_escapes(set))])
+      end
+    end
+
+    def special(token)
+      case token
+      when 'w' then WORD_CHARS.rand
+      when 'd' then NUMBERS.rand
+      when 's' then SPACES.rand
+      when *ESCAPEABLE_CHARS then token
+      end
+    end
+  end
+end

data/lib/ffaker/time.rb

@@ -0,0 +1,28 @@
+module Faker
+  module Time
+    extend ModuleUtils
+    extend self
+
+    def month
+      MONTHS.rand
+    end
+
+    def date(params={})
+      years_back = params[:year_range] || 5
+      latest_year  = params [:year_latest] || 0
+      year = (rand * (years_back)).ceil + (Object::Time.now.year - latest_year - years_back)
+      month = (rand * 12).ceil
+      day = (rand * 31).ceil
+      series = [date = Object::Time.local(year, month, day)]
+      if params[:series]
+        params[:series].each do |some_time_after|
+          series << series.last + (rand * some_time_after).ceil
+        end
+        return series
+      end
+      date
+    end
+
+    MONTHS = k %w(January February March April May June July August September October November December)
+  end
+end

data/lib/ffaker/venue.rb

@@ -0,0 +1,45 @@
+module Faker
+    # thanks to http://hipsteripsum.me
+    module Venue
+        extend ModuleUtils
+        extend self
+
+        def name
+          VENUE_LIST.rand
+        end
+
+        VENUE_LIST = k ["Barcelona Business Center",
+                        "Business Planet",
+                        "Can Domenge. Centre Tecnologic",
+                        "Casapiedra",
+                        "Centro de Convenciones Puebla William O. Jenkins",
+                        "Centro de Convenciones Torreon",
+                        "Centro de Eventos Castillo Hidalgo",
+                        "Centro de Exposiciones y Convenciones Las Americas",
+                        "Centro de Exposiciones y Convenciones del World Trade Center",
+                        "Centro de Exposiciones y Convenciones de Chihuahua",
+                        "Chez Moi",
+                        "Expo CenterNet de Argentina",
+                        "Expotrade",
+                        "Expourense",
+                        "Feria de Muestras de Navarra, S.L.",
+                        "Feria de Zaragoza",
+                        "Feria Internacional de Bilbao",
+                        "Feria Internacional de Galicia",
+                        "Feria Internacional de Muestras de Asturias",
+                        "Ferias y Congresos de Baleares",
+                        "Fundacion de Ferias y Exposiciones de Lugo",
+                        "Institucion Ferial de Calamocha",
+                        "Los Almendros de Huechuraba",
+                        "Oficina de Convenciones y Visitantes de Monterrey",
+                        "Oficina de Convenciones y Visitantes de Acapulco",
+                        "Palacio de Congresos de Cadiz",
+                        "Palacio de Congresos de Galicia",
+                        "Palacio de Congresos de La Coruna",
+                        "Palacio de Exposiciones y Congresos de Sevilla",
+                        "Palau de Congressos de Catalunya",
+                        "Parque Ferial On Line",
+                        "World Trade Center Barcelona",
+                        "World Trade Center Sevilla"]
+    end
+end

data/test/test_address.rb

@@ -1,6 +1,10 @@
 require 'helper'
 
 class TestAddress < Test::Unit::TestCase
+  def test_building_number
+    assert_match /\A\d{3,5}\z/, Faker::Address.building_number
+  end
+
   def test_city
     assert_match /[ a-z]+/, Faker::Address.city
   end
@@ -30,34 +34,38 @@ class TestAddress < Test::Unit::TestCase
   end
 
   def test_uk_country
-    assert_match /[ a-z]/, Faker::Address.uk_country
+    assert_match /[ a-z]/, Faker::AddressUK.country
   end
 
   def test_uk_county
-    assert_match /[ a-z]/, Faker::Address.uk_county
+    assert_match /[ a-z]/, Faker::AddressUK.county
   end
 
   def test_uk_postcode
-    assert_match /[ a-z]/, Faker::Address.uk_postcode
+    assert_match /[ a-z]/, Faker::AddressUK.postcode
   end
 
   def test_us_state
-    assert_match /[ a-z]/, Faker::Address.us_state
+    assert_match /[ a-z]/, Faker::AddressUS.state
   end
 
   def test_us_state_abbr
-    assert_match /[A-Z]/, Faker::Address.us_state_abbr
+    assert_match /[A-Z]/, Faker::AddressUS.state_abbr
   end
 
   def test_zip_code
-    assert_match /[0-9]/, Faker::Address.zip_code
+    assert_match /[0-9]/, Faker::AddressUS.zip_code
   end
 
   def test_zip_code_frozen
-    assert Faker::Address.zip_code.frozen? == false
+    assert Faker::AddressUS.zip_code.frozen? == false
   end
 
   def test_neighborhood
     assert_match /[ a-z]+/, Faker::Address::neighborhood
   end
+  
+  def test_country
+    assert_match /[ a-z]+/, Faker::Address::country
+  end
 end