ffaker 2.5.0 → 2.6.0

data/lib/ffaker/phone_number_au.rb

@@ -8,10 +8,10 @@ module FFaker
     extend self
 
     # Mobile prefixes
-    MobileOperatorsPrefix = %w(04).freeze
+    MobileOperatorsPrefix = %w(04 05).freeze
 
     # Home or Work Operator prefixes
-    HomeWorkOperatorsPrefix = %w(02 03 05 07 08).freeze
+    HomeWorkOperatorsPrefix = %w(02 03 07 08).freeze
 
     OperatorsPrefix = MobileOperatorsPrefix + HomeWorkOperatorsPrefix
 

data/lib/ffaker/phone_number_id.rb

@@ -6,7 +6,7 @@ module FFaker
     extend ModuleUtils
     extend self
 
-    COUNTRY_CODE = '+62'
+    COUNTRY_CODE = '+62'.freeze
 
     def mobile_phone_number
       "#{fetch_sample(MOBILE_PHONE_PREFIXES)}-#{FFaker.numerify('########')}"

data/lib/ffaker/string.rb

@@ -67,7 +67,7 @@ module FFaker
         end
         number = number.to_i - 1
         t = @last_token.dup
-        number.times.map { process_token(t.dup) }.join
+        Array.new(number) { process_token(t.dup) }.join
       else
         generate_token token, tokens
       end

data/lib/ffaker/tweet.rb

@@ -36,7 +36,7 @@ module FFaker
 
     def mentions(num = 2)
       mention_names = []
-      num.times{ mention_names << mention }
+      num.times { mention_names << mention }
       mention_names.join(' ')
     end
 

data/scripts/reference.rb

@@ -2,8 +2,8 @@ $LOAD_PATH << File.dirname(__FILE__) + '/../lib'
 require 'ffaker'
 
 ICONS = {
-  error: "‼️",
-  warning: "❗"
+  error: '‼️',
+  warning: '❗'
 }.freeze
 
 # Get a list of sections
@@ -60,11 +60,11 @@ sections = faker_modules.each.map do |mod|
     right = ''
 
     if arity > 0
-      left = "`#{meth}`(#{arity.times.map { '...' }.join(', ')})"
+      left = "`#{meth}`(#{Array.new(arity) { '...' }.join(', ')})"
     else
       begin
         examples, warnings = catch_warnings do
-          3.times.map { mod.send meth }
+          Array.new(3) { mod.send meth }
         end
         right = if warnings.any?
                   "#{ICONS[:warning]} *#{warnings.first}*"

data/test/test_address_br.rb

@@ -7,7 +7,7 @@ class TestAddressBR < Test::Unit::TestCase
 
   assert_methods_are_deterministic(
     FFaker::AddressBR,
-    :zip_code, :state, :state_abbr, :city, :street_prefix, :street
+    :zip_code, :state, :state_abbr, :city, :street_prefix, :street, :full_address
   )
 
   def test_zip_code

data/test/test_address_ca.rb

@@ -25,6 +25,7 @@ class TestAddressCA < Test::Unit::TestCase
   def test_postal_code
     assert_match(
       /\A[A-CEGHJK-NPR-TVXY]\d[A-CEGHJK-NPR-TV-Z] \d[A-CEGHJK-NPR-TV-Z]\d\z/,
-      FFaker::AddressCA.postal_code)
+      FFaker::AddressCA.postal_code
+    )
   end
 end

data/test/test_address_gr.rb

@@ -12,7 +12,7 @@ class TestAddressGR < Test::Unit::TestCase
 
   def setup
     @address_gr = FFaker::AddressGR
-    @street_prefix = FFaker::AddressGR::STREET_PREFIX.join("|")
+    @street_prefix = FFaker::AddressGR::STREET_PREFIX.join('|')
   end
 
   def test_city

data/test/test_address_mx.rb

@@ -5,7 +5,7 @@ require 'helper'
 # Author: guapolo github.com/guapolo
 class TestAddressMX < Test::Unit::TestCase
   include DeterministicHelper
-  
+
   assert_methods_are_deterministic(
     FFaker::AddressMX,
     :municipality, :postal_code, :state_abbr, :state, :zip_code

data/test/test_address_pl.rb

@@ -0,0 +1,81 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+require 'helper'
+
+class TestFakerAddressPL < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::AddressPL,
+    :full_address, :street_address, :street_name, :street, :square, :voivodeship,
+    :voivodeship_abbr, :voivodeship_capital_city, :city, :building_number,
+    :secondary_number, :postal_code, :street_prefix, :square_prefix
+  )
+
+  def setup
+    @tester = FFaker::AddressPL
+  end
+
+  def test_full_address
+    assert_match(/[a-z]/, @tester.full_address)
+  end
+
+  def test_full_address_includes_country
+    assert_match(/POLOGNE/, @tester.full_address(true))
+  end
+
+  def street_address
+    assert_match(/[a-z]/, @tester.street_address)
+  end
+
+  def street_name
+    prefix, street = @tester.street_name.split
+    assert_include(@tester::STREET_PREFIXES + @tester::SQUARE_PREFIXES, prefix)
+    assert_include(@tester::STREET + @tester::SQUARE, street)
+  end
+
+  def street
+    assert_include(@tester::STREET, @tester.street)
+  end
+
+  def square
+    assert_include(@tester::SQUARE, @tester.square)
+  end
+
+  def voivodeship
+    assert_include(@tester::VOIVODESHIP, @tester.voivodeship)
+  end
+
+  def voivodeship_abbr
+    assert_include(@tester::VOIVODESHIP_ABBR, @tester.voivodeship_abbr)
+  end
+
+  def voivodeship_capital_city
+    assert_include(@tester::VOIVODESHIP_CAPITAL_CITY, @tester.voivodeship_capital_city)
+  end
+
+  def city
+    assert_include(@tester::CITY, @tester.city)
+  end
+
+  def building
+    assert_match(/\d{1,3}/, @tester.building)
+  end
+
+  def secondary_number
+    assert_match(/\d{1,3}/, @tester.secondary_number.split.last)
+  end
+
+  def postal_code
+    assert_match(/\d{2}-\d{3}/, @tester.postal_code)
+  end
+
+  def street_prefix
+    assert_include(@tester::STREET_PREFIXES, @tester.square_prefix)
+  end
+
+  def square_prefix
+    assert_include(@tester::SQUARE_PREFIXES, @tester.square_prefix)
+  end
+end

data/test/test_address_ua.rb

@@ -43,7 +43,8 @@ class TestAddressUA < Test::Unit::TestCase
   def test_street_address_with_secondary
     assert_match( \
       /\Aвул\.\s[а-яА-ЯіїєґІЇЄҐ’\-\s]+,\s\d{1,3},\sкв\.\s\d{1,3}\z/,
-      @tester.street_address(true))
+      @tester.street_address(true)
+    )
   end
 
   def test_building_number

data/test/test_animal.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+require 'helper'
+
+class TestAnimals < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFaker::Animal, :common_name)
+
+  def setup
+    @tester = FFaker::Animal
+  end
+
+  def test_name
+    assert_include @tester::COMMON_NAMES, @tester.common_name
+  end
+end

data/test/test_aws.rb

@@ -8,15 +8,15 @@ class TestAWS < Test::Unit::TestCase
   assert_methods_are_deterministic(FFaker::AWS, :instance_type)
 
   def test_instance_type
-    assert_match(%r{\A[a-z]+\d\.\d*[a-z]+}, FFaker::AWS.instance_type)
+    assert_match(/\A[a-z]+\d\.\d*[a-z]+/, FFaker::AWS.instance_type)
   end
 
   def test_offering_type
-    assert_match(%r{\A[ a-zA-Z]+\z}i, FFaker::AWS.offering_type)
+    assert_match(/\A[ a-zA-Z]+\z/i, FFaker::AWS.offering_type)
   end
 
   def test_instance_tenancy
-    assert_match(%r{\A(?:default|dedicated|host)+\z}i, FFaker::AWS.instance_tenancy)
+    assert_match(/\A(?:default|dedicated|host)+\z/i, FFaker::AWS.instance_tenancy)
   end
 
   def test_product_description

data/test/test_book.rb

@@ -19,7 +19,7 @@ class TestBook < Test::Unit::TestCase
   end
 
   def test_genre
-    assert_match(%r([\w\s'\/]+), @tester.genre)
+    assert_match(%r{[\w\s'\/]+}, @tester.genre)
   end
 
   def test_author
@@ -35,7 +35,7 @@ class TestBook < Test::Unit::TestCase
   end
 
   def test_cover
-    assert_match(%r(\Ahttps:\/\/robohash\.org\/.+\.png\?size=300x300\z),
+    assert_match(%r{\Ahttps:\/\/robohash\.org\/.+\.png\?size=300x300\z},
                  @tester.cover)
   end
 end

data/test/test_filesystem.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+require 'helper'
+
+class TestFakerFilesystem < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::Filesystem,
+    :extension, :mime_type, :file_name
+  )
+
+  def setup
+    @tester = FFaker::Filesystem
+  end
+
+  def test_extension
+    assert @tester.extension.match(/(flac|mp3|wav|bmp|gif|jpeg|jpg|png|tiff|css|csv|html|js|json|txt|mp4|avi|mov|webm|doc|docx|xls|xlsx|ppt|pptx|odt|ods|odp|pages|numbers|key|pdf)/)
+  end
+
+  def test_mime_type_format
+    assert @tester.mime_type.match(/(.*)\/(.*)+/)
+  end
+
+  def test_file_name
+    assert @tester.file_name.match(/([a-z\-_]+)(\\|\/)([a-z\-_]+)\.([a-z]+)/)
+  end
+end

data/test/test_lorem_fr.rb

@@ -10,6 +10,7 @@ class TestLoremFR < Test::Unit::TestCase
     :paragraph, :paragraphs, :sentence, :sentences,
     :phrase, :phrases, :word, :words
   )
+  REGEX = /\A[ -.ÀÂÉÈÊÎÔÚÛàâéèêîôùûa-z]+\z/i
 
   def test_paragraph
     assert_match(/\A[ -.àâéèêîôùûa-z]+\z/i, FFaker::LoremFR.paragraph)
@@ -24,7 +25,7 @@ class TestLoremFR < Test::Unit::TestCase
   end
 
   def test_paragraphsLoremFR
-    assert_match(/\A[ -.àâéèêîôùûa-z]+\z/i, FFaker::LoremFR.paragraphs.join(' '))
+    assert_match(REGEX, FFaker::LoremFR.paragraphs.join(' '))
   end
 
   def test_sentences

data/test/test_name_br.rb

@@ -22,7 +22,7 @@ class TestFakerNameBR < Test::Unit::TestCase
   def test_name_with_prefix
     prefix, name, last_name = @tester.name_with_prefix.split(/\s+/)
     assert_include(@tester::PREFIXES, prefix)
-    assert(name.length > 0)
+    assert(!name.empty?)
     refute_empty(last_name)
   end
 

data/test/test_name_pl.rb

@@ -0,0 +1,112 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+require 'helper'
+
+class TestFakerNamePL < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::NamePL,
+    :name, :name_with_prefix, :last_name, :first_name, :female_name_with_prefix,
+    :male_name_with_prefix, :female_full_name, :male_full_name, :female_first_name,
+    :female_last_name, :male_first_name, :male_last_name, :prefix,
+    :female_prefix, :male_prefix, :academic_degree_prefix
+  )
+
+  def setup
+    @tester = FFaker::NamePL
+  end
+
+  def test_name
+    assert_match(/(\w+\.? ?){2}/, @tester.name)
+  end
+
+  def name_with_prefix
+    prefix, first_name, last_name = @tester.name_with_prefix.split
+    assert_include(@tester::PREFIXES, prefix)
+    refute_empty(first_name)
+    refute_empty(last_name)
+  end
+
+  def test_female_name_with_prefix
+    prefix, first_name, last_name = @tester.female_name_with_prefix.split
+    assert_include(@tester::FEMALE_PREFIXES, prefix)
+    assert_include(@tester::FEMALE_FIRST_NAMES, first_name)
+    assert_include(@tester::FEMALE_LAST_NAMES, last_name)
+  end
+
+  def test_male_name_with_prefix
+    prefix, first_name, last_name = @tester.male_name_with_prefix.split
+    assert_include(@tester::MALE_PREFIXES, prefix)
+    assert_include(@tester::MALE_FIRST_NAMES, first_name)
+    assert_include(@tester::MALE_LAST_NAMES, last_name)
+  end
+
+  def test_female_full_name
+    first_name, last_name = @tester.female_full_name.split
+    assert_include(@tester::FEMALE_FIRST_NAMES, first_name)
+    assert_include(@tester::FEMALE_LAST_NAMES, last_name)
+  end
+
+  def test_male_full_name
+    first_name, last_name = @tester.male_full_name.split
+    assert_include(@tester::MALE_FIRST_NAMES, first_name)
+    assert_include(@tester::MALE_LAST_NAMES, last_name)
+  end
+
+  def test_first_name
+    first_names = @tester::FEMALE_FIRST_NAMES + @tester::MALE_FIRST_NAMES
+    assert_include(first_names, @tester.first_name)
+  end
+
+  def test_first_name_with_argument
+    assert_include(@tester::FEMALE_FIRST_NAMES, @tester.first_name(:female))
+  end
+
+  def test_female_first_name
+    assert_include(@tester::FEMALE_FIRST_NAMES, @tester.female_first_name)
+  end
+
+  def test_male_first_name
+    assert_include(@tester::MALE_FIRST_NAMES, @tester.male_first_name)
+  end
+
+  def test_last_name
+    last_names = @tester::FEMALE_LAST_NAMES + @tester::MALE_LAST_NAMES
+    assert_include(last_names, @tester.last_name)
+  end
+
+  def test_last_name_with_argument
+    assert_include(@tester::MALE_LAST_NAMES, @tester.last_name(:male))
+  end
+
+  def test_female_last_name
+    assert_include(@tester::FEMALE_LAST_NAMES, @tester.female_last_name)
+  end
+
+  def test_male_last_name
+    assert_include(@tester::MALE_LAST_NAMES, @tester.male_last_name)
+  end
+
+  def test_prefix
+    assert_include(@tester::PREFIXES, @tester.prefix)
+  end
+
+  def test_female_prefix
+    assert_include(@tester::FEMALE_PREFIXES, @tester.female_prefix)
+  end
+
+  def test_male_prefix
+    assert_include(@tester::MALE_PREFIXES, @tester.male_prefix)
+  end
+
+  def test_academic_degree_prefix
+    assert_include(@tester::ACADEMIC_DEGREE_PREFIXES, @tester.academic_degree_prefix)
+  end
+
+  def test_name_for_gender_raises_argument_error
+    error = assert_raises(ArgumentError) { @tester.send(:name_for_gender, :name, :vodka) }
+    assert_match("Gender must be one of: #{@tester::GENDERS}", error.message)
+  end
+end

data/test/test_phone_number_au.rb

@@ -20,42 +20,47 @@ class TestPhoneNumberAU < Test::Unit::TestCase
   end
 
   def test_mobile_phone_prefix
-    assert FFaker::PhoneNumberAU::MobileOperatorsPrefix.include?(@tester.mobile_phone_prefix)
+    assert_include(FFaker::PhoneNumberAU::MobileOperatorsPrefix,
+                   @tester.mobile_phone_prefix)
   end
 
   def test_home_work_phone_prefix
-    assert FFaker::PhoneNumberAU::HomeWorkOperatorsPrefix.include?(@tester.home_work_phone_prefix)
+    assert_include(FFaker::PhoneNumberAU::HomeWorkOperatorsPrefix,
+                   @tester.home_work_phone_prefix)
   end
 
   def test_phone_prefix
-    assert FFaker::PhoneNumberAU::OperatorsPrefix.include?(@tester.phone_prefix)
+    assert_include(FFaker::PhoneNumberAU::OperatorsPrefix,
+                   @tester.phone_prefix)
   end
 
   def test_mobile_phone_number
-    assert_match(/04\d{2} \d{3} \d{3}/, FFaker::PhoneNumberAU.mobile_phone_number)
+    assert_match(/0[45]\d{2} \d{3} \d{3}/,
+                 FFaker::PhoneNumberAU.mobile_phone_number)
   end
 
   def test_home_work_phone_number
-    assert_match(/\(\d{2}\) \d{4} \d{4}/, FFaker::PhoneNumberAU.home_work_phone_number)
+    assert_match(/\(\d{2}\) \d{4} \d{4}/,
+                 FFaker::PhoneNumberAU.home_work_phone_number)
   end
 
   def test_phone_number
-    10.times do
-      assert_match(/(04\d{1,2} \d{3} \d{3}|\(\d{2}\) \d{4} \d{4})/, FFaker::PhoneNumberAU.phone_number)
-    end
+    assert_match(/(?:0[45]\d{1,2} \d{3} \d{3}|\(\d{2}\) \d{4} \d{4})/,
+                 FFaker::PhoneNumberAU.phone_number)
   end
 
   def test_international_mobile_phone_number
-    assert_match(/\+61 \d{1,2} \d{4} \d{4}/, FFaker::PhoneNumberAU.international_mobile_phone_number)
+    assert_match(/\+61 \d{1,2} \d{4} \d{4}/,
+                 FFaker::PhoneNumberAU.international_mobile_phone_number)
   end
 
   def test_international_home_work_phone_number
-    assert_match(/\+61 \d{1,2} \d{4} \d{4}/, FFaker::PhoneNumberAU.international_home_work_phone_number)
+    assert_match(/\+61 \d{1,2} \d{4} \d{4}/,
+                 FFaker::PhoneNumberAU.international_home_work_phone_number)
   end
 
   def test_international_phone_number
-    10.times do
-      assert_match(/\+61 \d{1,2} \d{4} \d{4}/, FFaker::PhoneNumberAU.international_phone_number)
-    end
+    assert_match(/\+61 \d{1,2} \d{4} \d{4}/,
+                 FFaker::PhoneNumberAU.international_phone_number)
   end
 end