ffaker 2.13.0 → 2.18.0

data/lib/ffaker/utils/unique_utils.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'set'
-
 module FFaker
   class UniqueUtils
     def initialize(generator, max_retries)

data/lib/ffaker/vehicle.rb

@@ -6,7 +6,7 @@ module FFaker
     extend self
 
     DRIVETRAINS = %w[4WD 4X4 AWD FWD RWD].freeze
-    YEARS = [*'1900'..(::Time.now.year + 1).to_s].freeze
+    YEARS = Array('1900'..(::Time.now.year + 1).to_s).freeze
     TRANSMISSIONS_ABBR = %w[AT MT AM CVT].freeze
     CYLINDERS = %w[2 5 6 8].freeze
 

data/lib/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module FFaker
+  VERSION = '2.18.0'
+end

data/scripts/benchmark.rb

@@ -1,22 +1,21 @@
 # frozen_string_literal: true
 
-require 'rubygems'
 require 'benchmark'
 
-N = 10_000
+NAMES_COUNT = 10_000
 
 def run(name)
-  require name
   Benchmark.bm do |rep|
-    rep.report("generating #{N} names (#{name} #{FFaker::VERSION})") do
-      N.times do
-        FFaker::Name.name
-      end
+    rep.report("generating #{NAMES_COUNT} names (#{name})") do
+      mod = name == 'ffaker' ? FFaker : Faker
+      NAMES_COUNT.times { mod::Name.name }
     end
   end
-  $stdout.flush
-  exit(0)
 end
 
-fork { run('faker') }; Process.wait
-fork { run('ffaker') }; Process.wait
+%w[faker ffaker].each do |gem_name|
+  require gem_name
+
+  fork { run(gem_name) }
+  Process.wait
+end

data/test/helper.rb

@@ -45,9 +45,9 @@ module DeterministicHelper
     end
   end
 
-  def assert_between(got, from, to, exclude_end: false)
-    assert_greater_than_or_equal_to got, from
-    public_send "assert_less_than#{'_or_equal_to' unless exclude_end}", got, to
+  def assert_between(got, range)
+    assert_greater_than_or_equal_to got, range.begin
+    public_send "assert_less_than#{'_or_equal_to' unless range.exclude_end?}", got, range.end
   end
 
   def assert_random(original_block, *args)

data/test/test_address_au.rb

@@ -33,7 +33,7 @@ class TestAddressAU < Test::Unit::TestCase
   end
 
   def test_full_address
-    assert_match(/[\, a-z]/, FFaker::AddressAU.full_address)
+    assert_match(/[, a-z]/, FFaker::AddressAU.full_address)
   end
 
   def test_au_suburb_with_states
@@ -60,7 +60,7 @@ class TestAddressAU < Test::Unit::TestCase
 
   def test_full_address_with_states
     FFaker::AddressAU::STATE_ABBR.each do |st_abbr|
-      assert_match(/[\, a-z]/, FFaker::AddressAU.full_address(st_abbr))
+      assert_match(/[, a-z]/, FFaker::AddressAU.full_address(st_abbr))
       assert_deterministic { FFaker::AddressAU.full_address(st_abbr) }
     end
   end

data/test/test_address_br.rb

@@ -32,6 +32,6 @@ class TestAddressBR < Test::Unit::TestCase
 
   def test_street
     prefixes = FFaker::AddressBR::STREET_PREFIX
-    assert_match(/(#{prefixes.join('|')})( [\p{Alpha}]+){1,2}/, FFaker::AddressBR.street)
+    assert_match(/(#{prefixes.join('|')})( \p{Alpha}+){1,2}/, FFaker::AddressBR.street)
   end
 end

data/test/test_address_fi.rb

@@ -5,7 +5,7 @@ require 'helper'
 class TestAddressFI < Test::Unit::TestCase
   include DeterministicHelper
 
-  ALPHA = /\A[\p{Alpha}]+/.freeze
+  ALPHA = /\A\p{Alpha}+/.freeze
   DIGIT = /\d{1}/.freeze
 
   assert_methods_are_deterministic(
@@ -30,7 +30,7 @@ class TestAddressFI < Test::Unit::TestCase
     assert_match(ALPHA, address)
     assert_match(DIGIT, address)
     assert_match(/SUOMI/, address)
-    assert_match(/[\, a-z]/, address)
+    assert_match(/[, a-z]/, address)
   end
 
   def test_fi_zip_code_frozen

data/test/test_address_fr.rb

@@ -7,6 +7,6 @@ class TestAddressFR < Test::Unit::TestCase
 
   assert_methods_are_deterministic(
     FFaker::AddressFR,
-    :city, :full_address, :street_name, :postal_code
+    :city, :full_address, :street_name, :postal_code, :region
   )
 end

data/test/test_address_id.rb

@@ -33,7 +33,7 @@ class TestAddressID < Test::Unit::TestCase
   def test_street
     prefixes = FFaker::AddressID::STREET_PREFIX
     common_street_names = FFaker::AddressID::COMMON_STREET_NAMES
-    regex = /\A(#{prefixes.join('|')})\.(\s(#{common_street_names.join('|')}))\,\sNo\.\s\d+\z/
+    regex = /\A(#{prefixes.join('|')})\.(\s(#{common_street_names.join('|')})),\sNo\.\s\d+\z/
     assert_match(regex, FFaker::AddressID.street)
   end
 end

data/test/test_address_ja.rb

@@ -13,7 +13,7 @@ class TestAddressJA < Test::Unit::TestCase
   )
 
   def test_postal_code
-    assert_match(/^\d{3}\-\d{4}$/, FFaker::AddressJA.postal_code)
+    assert_match(/^\d{3}-\d{4}$/, FFaker::AddressJA.postal_code)
   end
 
   def test_land_number

data/test/test_address_nl.rb

@@ -23,7 +23,7 @@ class TestAddressNL < Test::Unit::TestCase
   end
 
   def test_zip_code
-    assert_match(/^\d{4}\s\w{2}$/, @tester.zip_code)
+    assert_match(/\A[1-9]\d{3} [A-RT-Z][A-Z]\z/, @tester.zip_code)
   end
 
   def test_street_name

data/test/test_address_se.rb

@@ -5,7 +5,7 @@ require 'helper'
 class TestAddressSE < Test::Unit::TestCase
   include DeterministicHelper
 
-  ALPHA = /\A[\p{Alpha}]+/.freeze
+  ALPHA = /\A\p{Alpha}+/.freeze
   DIGIT = /\d{1}/.freeze
 
   assert_methods_are_deterministic(
@@ -30,7 +30,7 @@ class TestAddressSE < Test::Unit::TestCase
     assert_match(ALPHA, address)
     assert_match(DIGIT, address)
     assert_match(/SVERIGE/, address)
-    assert_match(/[\, a-z]/, address)
+    assert_match(/[, a-z]/, address)
   end
 
   def test_se_zip_code_frozen

data/test/test_animal_es.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'helper'
+
+class TestAnimalsES < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFaker::AnimalES, :common_name)
+
+  def setup
+    @tester = FFaker::AnimalES
+  end
+
+  def test_name
+    assert_include @tester::COMMON_NAMES, @tester.common_name
+  end
+end

data/test/test_array_utils.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'helper'
-require 'set'
 
 class TestArrayUtils < Test::Unit::TestCase
   include DeterministicHelper

data/test/test_aws.rb

@@ -20,6 +20,6 @@ class TestAWS < Test::Unit::TestCase
   end
 
   def test_product_description
-    assert_match(%r{\A[ \/a-zA-Z\(\)]+\z}i, FFaker::AWS.product_description)
+    assert_match(%r{\A[ /a-zA-Z()]+\z}i, FFaker::AWS.product_description)
   end
 end

data/test/test_bank.rb

@@ -33,7 +33,7 @@ class TestBank < Test::Unit::TestCase
     date_today = ::DateTime.now
 
     assert_random_between(
-      date_today.strftime('%y'), date_today.next_year(5).strftime('%y')
+      date_today.strftime('%y')..date_today.next_year(5).strftime('%y')
     ) do
       @tester.card_expiry_date.split('/').pop
     end
@@ -41,8 +41,7 @@ class TestBank < Test::Unit::TestCase
     year_range = 4
     year_latest = 8
     assert_random_between(
-      date_today.prev_year(year_latest + year_range).strftime('%y'),
-      date_today.prev_year(year_latest).strftime('%y')
+      date_today.prev_year(year_latest + year_range).strftime('%y')..date_today.prev_year(year_latest).strftime('%y')
     ) do
       @tester.card_expiry_date(year_range: year_range, year_latest: year_latest).split('/').pop
     end

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
@@ -27,7 +27,7 @@ class TestBook < Test::Unit::TestCase
   end
 
   def test_isbn
-    assert_match(/[\d]+/, @tester.isbn)
+    assert_match(/\d+/, @tester.isbn)
   end
 
   def test_description
@@ -35,12 +35,12 @@ 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
 
   def test_orly_cover
-    assert_match(%r{\Ahttps:\/\/orly-appstore\.herokuapp\.com\/generate},
+    assert_match(%r{\Ahttps://orly-appstore\.herokuapp\.com/generate},
                  @tester.orly_cover)
   end
 end

data/test/test_code.rb

@@ -5,7 +5,28 @@ require 'helper'
 class TestCode < Test::Unit::TestCase
   include DeterministicHelper
 
-  assert_methods_are_deterministic(FFaker::Code, :ean)
+  assert_methods_are_deterministic(FFaker::Code, :ean, :npi)
+
+  def test_npi_legacy_regexp
+    assert FFaker::Code.npi(legacy: true).match(/\A(1|2)[0-9]{9}\z/)
+  end
+
+  def test_npi
+    FFaker::Random.seed = 523_456_789
+    assert FFaker::Code.npi == '7411850515'
+  end
+
+  def test_deterministic_npi
+    FFaker::Random.seed = 42
+    v = FFaker::Code.npi
+    FFaker::Random.reset!
+    assert v == FFaker::Code.npi
+  end
+
+  def test_valid_npi
+    FFaker::Random.seed = 123_456_789
+    assert FFaker::Code.npi == '2410167607'
+  end
 
   def test_ean
     assert FFaker::Code.ean.match(/^\d{13}$/)

data/test/test_company_ja.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'helper'
+
+class TestCompanyJA < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::CompanyJA,
+    :name, :position
+  )
+
+  def setup
+    @tester = FFaker::CompanyJA
+  end
+
+  def test_name
+    assert_match(japanese_regex(''), @tester.name)
+  end
+
+  def test_position
+    assert_match(japanese_regex(''), @tester.position)
+  end
+
+  def japanese_regex(word)
+    /\A(?:\p{Hiragana}|\p{Katakana}|[ー－]|[一-龠々])+#{word}\z/
+  end
+end

data/test/{test_faker.rb → test_ffaker.rb}

@@ -2,9 +2,13 @@
 
 require 'helper'
 
-class TestFaker < Test::Unit::TestCase
+class TestFFaker < Test::Unit::TestCase
   include DeterministicHelper
 
+  def test_version
+    assert FFaker::VERSION.is_a?(String)
+  end
+
   def test_numerify
     assert FFaker.numerify('###').match(/\d{3}/)
     assert_deterministic { FFaker.numerify('###') }

data/test/test_filesystem.rb

@@ -15,14 +15,22 @@ class TestFakerFilesystem < Test::Unit::TestCase
   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)/)
+    assert_match /\A(?: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)\z/x,
+                 @tester.extension
   end
 
   def test_mime_type_format
-    assert @tester.mime_type.match(%r{(.*)/(.*)+})
+    assert_match %r{\A\w+/.+\z}, @tester.mime_type
+  end
+
+  def test_directory
+    assert_match %r{\A(?:[a-z_-]+[\\/])+[a-z_-]+\z}, @tester.directory
   end
 
   def test_file_name
-    assert @tester.file_name.match(%r{([a-z\-_]+)(\\|/)([a-z\-_]+)\.([a-z]+)})
+    assert_match %r{\A(?:[a-z_-]+[\\/])+[a-z_-]+\.\w{2,4}\z},
+      @tester.file_name
   end
 end

data/test/test_food_pl.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'helper'
+
+class TestFakerFoodPL < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::FoodPL,
+    :food, :processed, :unprocessed, :vegetable, :fruit,
+    :meat, :herb, :spice, :fermented, :diary, :preserves
+  )
+
+  def setup
+    @tester = FFaker::FoodPL
+  end
+
+  def test_food
+    assert_match(/\w+/, @tester.food)
+  end
+
+  def test_processed
+    assert_match(/\w+/, @tester.processed)
+  end
+
+  def test_unprocessed
+    assert_match(/\w+/, @tester.unprocessed)
+  end
+
+  def test_vegetable
+    assert_include(@tester::VEGETABLES, @tester.vegetable)
+  end
+
+  def test_fruit
+    assert_include(@tester::FRUITS, @tester.fruit)
+  end
+
+  def test_herb
+    assert_include(@tester::HERBS, @tester.herb)
+  end
+
+  def test_spice
+    assert_include(@tester::SPICES, @tester.spice)
+  end
+
+  def test_meat
+    assert_include(@tester::MEATS, @tester.meat)
+  end
+
+  def test_fermented
+    assert_include(@tester::FERMENTED, @tester.fermented)
+  end
+
+  def test_diary
+    assert_include(@tester::DIARY, @tester.diary)
+  end
+
+  def test_preserves
+    assert_include(@tester::PRESERVES, @tester.preserves)
+  end
+end

data/test/test_freedom_ipsum.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'helper'
+class TestFreedomIpsum < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::FreedomIpsum,
+    :word, :words
+  )
+
+  TEST_REGEX = /[a-z0-9 -]+/i.freeze
+
+  def test_words
+    assert_match(TEST_REGEX, FFaker::FreedomIpsum.words.join(' '))
+  end
+
+  def test_word
+    assert_match(TEST_REGEX, FFaker::FreedomIpsum.word)
+  end
+end