ffaker 2.10.0 → 2.23.0

data/lib/ffaker.rb

@@ -1,193 +1,105 @@
-module FFaker
-  VERSION = '2.10.0'.freeze
+# frozen_string_literal: true
+
+require_relative 'ffaker/version'
+require 'pathname'
 
-  require 'ffaker/utils/array_utils'
-  require 'ffaker/utils/module_utils'
+module FFaker
+  require_relative 'ffaker/utils/array_utils'
+  require_relative 'ffaker/utils/module_utils'
 
   extend ModuleUtils
 
-  BASE_LIB_PATH = File.expand_path('..', __FILE__)
+  BASE_LIB_PATH = File.expand_path(__dir__)
 
-  LETTERS = [*'a'..'z'].freeze
+  LETTERS = Array('a'..'z').freeze
 
   HEX = %w[0 1 2 3 4 5 6 7 8 9 A B C D E F].freeze
 
   def self.hexify(*masks)
-    fetch_sample(masks.flatten).gsub(/#/) { fetch_sample(HEX) }
+    fetch_sample(masks.flatten).gsub('#') { fetch_sample(HEX) }
   end
 
   def self.numerify(*masks)
-    fetch_sample(masks.flatten).gsub(/#/) { rand(0..9).to_s }
+    fetch_sample(masks.flatten).gsub('#') { rand(0..9).to_s }
   end
 
   def self.letterify(*masks)
-    fetch_sample(masks.flatten).gsub(/\?/) { fetch_sample(LETTERS) }
+    fetch_sample(masks.flatten).gsub('?') { fetch_sample(LETTERS) }
   end
 
   def self.bothify(masks)
     letterify(numerify(masks))
   end
 
-  autoload :Address, 'ffaker/address'
-  autoload :AddressAU, 'ffaker/address_au'
-  autoload :AddressBR, 'ffaker/address_br'
-  autoload :AddressCA, 'ffaker/address_ca'
-  autoload :AddressCH, 'ffaker/address_ch'
-  autoload :AddressCHDE, 'ffaker/address_ch_de'
-  autoload :AddressCHFR, 'ffaker/address_ch_fr'
-  autoload :AddressCHIT, 'ffaker/address_ch_it'
-  autoload :AddressDA, 'ffaker/address_da'
-  autoload :AddressDE, 'ffaker/address_de'
-  autoload :AddressFI, 'ffaker/address_fi'
-  autoload :AddressFR, 'ffaker/address_fr'
-  autoload :AddressGR, 'ffaker/address_gr'
-  autoload :AddressID, 'ffaker/address_id'
-  autoload :AddressIN, 'ffaker/address_in'
-  autoload :AddressJA, 'ffaker/address_ja'
-  autoload :AddressKR, 'ffaker/address_kr'
-  autoload :AddressMX, 'ffaker/address_mx'
-  autoload :AddressNL, 'ffaker/address_nl'
-  autoload :AddressPL, 'ffaker/address_pl'
-  autoload :AddressRU, 'ffaker/address_ru'
-  autoload :AddressSE, 'ffaker/address_se'
-  autoload :AddressSN, 'ffaker/address_sn'
-  autoload :AddressUA, 'ffaker/address_ua'
-  autoload :AddressUK, 'ffaker/address_uk'
-  autoload :AddressUS, 'ffaker/address_us'
-  autoload :Airline, 'ffaker/airline'
-  autoload :Animal, 'ffaker/animals'
-  autoload :Avatar, 'ffaker/avatar'
-  autoload :AWS, 'ffaker/aws'
-  autoload :BaconIpsum, 'ffaker/bacon_ipsum'
-  autoload :Book, 'ffaker/book'
-  autoload :Boolean, 'ffaker/boolean'
-  autoload :CheesyLingo, 'ffaker/cheesy_lingo'
-  autoload :Code, 'ffaker/code'
-  autoload :Color, 'ffaker/color'
-  autoload :ColorUA, 'ffaker/color_ua'
-  autoload :Company, 'ffaker/company'
-  autoload :CompanyCN, 'ffaker/company_cn'
-  autoload :CompanyIT, 'ffaker/company_it'
-  autoload :CompanySE, 'ffaker/company_se'
-  autoload :Conference, 'ffaker/conference'
-  autoload :CoursesFR, 'ffaker/courses'
-  autoload :Currency, 'ffaker/currency'
-  autoload :DizzleIpsum, 'ffaker/dizzle_ipsum'
-  autoload :Education, 'ffaker/education'
-  autoload :Filesystem, 'ffaker/filesystem'
-  autoload :Food, 'ffaker/food'
-  autoload :Gender, 'ffaker/gender'
-  autoload :GenderBR, 'ffaker/gender_br'
-  autoload :GenderCN, 'ffaker/gender_cn'
-  autoload :GenderID, 'ffaker/gender_id'
-  autoload :GenderKR, 'ffaker/gender_kr'
-  autoload :Geolocation, 'ffaker/geolocation'
-  autoload :Guid, 'ffaker/guid'
-  autoload :HealthcareIpsum, 'ffaker/healthcare_ipsum'
-  autoload :HipsterIpsum, 'ffaker/hipster_ipsum'
-  autoload :HTMLIpsum, 'ffaker/html_ipsum'
-  autoload :Identification, 'ffaker/identification'
-  autoload :IdentificationBR, 'ffaker/identification_br'
-  autoload :IdentificationES, 'ffaker/identification_es'
-  autoload :IdentificationESCL, 'ffaker/identification_es_cl'
-  autoload :IdentificationESCO, 'ffaker/identification_es_co'
-  autoload :IdentificationKr, 'ffaker/identification_kr'
-  autoload :IdentificationMX, 'ffaker/identification_mx'
-  autoload :Image, 'ffaker/image'
-  autoload :Internet, 'ffaker/internet'
-  autoload :InternetSE, 'ffaker/internet_se'
-  autoload :Job, 'ffaker/job'
-  autoload :JobBR, 'ffaker/job_br'
-  autoload :JobCN, 'ffaker/job_cn'
-  autoload :JobFR, 'ffaker/job_fr'
-  autoload :JobJA, 'ffaker/job_ja'
-  autoload :JobKR, 'ffaker/job_kr'
-  autoload :JobVN, 'ffaker/job_vn'
-  autoload :Locale, 'ffaker/locale'
-  autoload :Lorem, 'ffaker/lorem'
-  autoload :LoremAR, 'ffaker/lorem_ar'
-  autoload :LoremCN, 'ffaker/lorem_cn'
-  autoload :LoremFR, 'ffaker/lorem_fr'
-  autoload :LoremIE, 'ffaker/lorem_ie'
-  autoload :LoremJA, 'ffaker/lorem_ja'
-  autoload :LoremKR, 'ffaker/lorem_kr'
-  autoload :LoremPL, 'ffaker/lorem_pl'
-  autoload :LoremRU, 'ffaker/lorem_ru'
-  autoload :LoremUA, 'ffaker/lorem_ua'
-  autoload :Movie, 'ffaker/movie'
-  autoload :Music, 'ffaker/music'
-  autoload :Name, 'ffaker/name'
-  autoload :NameAR, 'ffaker/name_ar'
-  autoload :NameBR, 'ffaker/name_br'
-  autoload :NameCN, 'ffaker/name_cn'
-  autoload :NameCS, 'ffaker/name_cs'
-  autoload :NameDA, 'ffaker/name_da'
-  autoload :NameDE, 'ffaker/name_de'
-  autoload :NameES, 'ffaker/name_es'
-  autoload :NameFR, 'ffaker/name_fr'
-  autoload :NameGA, 'ffaker/name_ga'
-  autoload :NameGR, 'ffaker/name_gr'
-  autoload :NameID, 'ffaker/name_id'
-  autoload :NameIT, 'ffaker/name_it'
-  autoload :NameJA, 'ffaker/name_ja'
-  autoload :NameKH, 'ffaker/name_kh'
-  autoload :NameKR, 'ffaker/name_kr'
-  autoload :NameMX, 'ffaker/name_mx'
-  autoload :NameNB, 'ffaker/name_nb'
-  autoload :NameNL, 'ffaker/name_nl'
-  autoload :NamePH, 'ffaker/name_ph'
-  autoload :NamePL, 'ffaker/name_pl'
-  autoload :NameRU, 'ffaker/name_ru'
-  autoload :NameSE, 'ffaker/name_se'
-  autoload :NameSN, 'ffaker/name_sn'
-  autoload :NameTH, 'ffaker/name_th'
-  autoload :NameTHEN, 'ffaker/name_th_en'
-  autoload :NameUA, 'ffaker/name_ua'
-  autoload :NameVN, 'ffaker/name_vn'
-  autoload :NatoAlphabet, 'ffaker/nato_alphabet'
-  autoload :PhoneNumber, 'ffaker/phone_number'
-  autoload :PhoneNumberAU, 'ffaker/phone_number_au'
-  autoload :PhoneNumberBR, 'ffaker/phone_number_br'
-  autoload :PhoneNumberCH, 'ffaker/phone_number_ch'
-  autoload :PhoneNumberCU, 'ffaker/phone_number_cu'
-  autoload :PhoneNumberDA, 'ffaker/phone_number_da'
-  autoload :PhoneNumberDE, 'ffaker/phone_number_de'
-  autoload :PhoneNumberFR, 'ffaker/phone_number_fr'
-  autoload :PhoneNumberID, 'ffaker/phone_number_id'
-  autoload :PhoneNumberIT, 'ffaker/phone_number_it'
-  autoload :PhoneNumberKR, 'ffaker/phone_number_kr'
-  autoload :PhoneNumberMX, 'ffaker/phone_number_mx'
-  autoload :PhoneNumberNL, 'ffaker/phone_number_nl'
-  autoload :PhoneNumberSE, 'ffaker/phone_number_se'
-  autoload :PhoneNumberSG, 'ffaker/phone_number_sg'
-  autoload :PhoneNumberSN, 'ffaker/phone_number_sn'
-  autoload :Product, 'ffaker/product'
-  autoload :Skill, 'ffaker/skill'
-  autoload :Sport, 'ffaker/sport'
-  autoload :SSN, 'ffaker/ssn'
-  autoload :SSNMX, 'ffaker/ssn_mx'
-  autoload :SSNSE, 'ffaker/ssn_se'
-  autoload :String, 'ffaker/string'
-  autoload :Time, 'ffaker/time'
-  autoload :Tweet, 'ffaker/tweet'
-  autoload :Unit, 'ffaker/unit'
-  autoload :UnitEnglish, 'ffaker/unit_english'
-  autoload :UnitMetric, 'ffaker/unit_metric'
-  autoload :Vehicle, 'ffaker/vehicle'
-  autoload :Venue, 'ffaker/venue'
-  autoload :Youtube, 'ffaker/youtube'
+  autoload_acronyms = {
+    'ar' => 'AR',
+    'au' => 'AU',
+    'aws' => 'AWS',
+    'br' => 'BR',
+    'ca' => 'CA',
+    'ch' => 'CH',
+    'cl' => 'CL',
+    'cn' => 'CN',
+    'co' => 'CO',
+    'cs' => 'CS',
+    'cu' => 'CU',
+    'da' => 'DA',
+    'de' => 'DE',
+    'ec' => 'EC',
+    'en' => 'EN',
+    'es' => 'ES',
+    'fi' => 'FI',
+    'fr' => 'FR',
+    'ga' => 'GA',
+    'gr' => 'GR',
+    'html' => 'HTML',
+    'id' => 'ID',
+    'ie' => 'IE',
+    'in' => 'IN',
+    'it' => 'IT',
+    'ja' => 'JA',
+    'jp' => 'JP',
+    'kh' => 'KH',
+    'kr' => 'KR',
+    'mx' => 'MX',
+    'nb' => 'NB',
+    'nl' => 'NL',
+    'ph' => 'PH',
+    'pl' => 'PL',
+    'ru' => 'RU',
+    'se' => 'SE',
+    'sg' => 'SG',
+    'sn' => 'SN',
+    'ssn' => 'SSN',
+    'th' => 'TH',
+    'tw' => 'TW',
+    'ua' => 'UA',
+    'uk' => 'UK',
+    'us' => 'US',
+    'vn' => 'VN'
+  }
+
+  directory = "#{__dir__}/ffaker"
+  Dir["#{directory}/*.rb"].each do |file_name|
+    relative_file_path = Pathname.new(file_name).relative_path_from(directory).to_s.chomp('.rb')
+    ## Don't consider files in sub-directories
+    constant_name = relative_file_path.split('_').map do |part|
+      autoload_acronyms.fetch(part) { part.capitalize }
+    end.join
+    autoload constant_name, file_name
+  end
 
   # Random Number Generator (RNG) used with ModuleUtils#fetch, #shuffle, #rand
   # in order to provide deterministic repeatability.
   module Random
     # Returns the current RNG seed.
     def self.seed
-      @random_seed ||= ::Random.new_seed
+      @seed ||= ::Random.new_seed
     end
 
     # Sets the RNG seed and creates a new internal RNG.
     def self.seed=(new_seed)
-      @random_seed = new_seed
+      @seed = new_seed
       reset!
       new_seed
     end
@@ -199,11 +111,9 @@ module FFaker
 
     # Returns a random number using an RNG with a known seed.
     def self.rand(max = nil)
-      if max
-        rng.rand(max)
-      else
-        rng.rand
-      end
+      return rng.rand(max) if max
+
+      rng.rand
     end
 
     # Returns the current Random object.

data/scripts/benchmark.rb

@@ -1,20 +1,21 @@
-require 'rubygems'
+# frozen_string_literal: true
+
 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/scripts/profiling.rb

@@ -1,4 +1,6 @@
-require File.dirname(__FILE__) + '/../lib/faker'
+# frozen_string_literal: true
+
+require_relative '../lib/faker'
 
 N = 1_000_000
 

data/scripts/reference.rb

@@ -1,28 +1,32 @@
-$LOAD_PATH << File.dirname(__FILE__) + '/../lib'
-require 'ffaker'
+# frozen_string_literal: true
+
+require_relative '../lib/ffaker'
+require 'set'
+
+# always use the same seed for consistency
+FFaker::Random.seed = 1337
 
 ICONS = {
   error: '‼️',
   warning: '❗'
 }.freeze
 
+UTILS_MODULES = %i[ArrayUtils ModuleUtils RandomUtils Random Version].freeze
+UTILS_METHODS = %i[k underscore fetch_sample rand shuffle unique luhn_check].freeze
+
 # Get a list of sections
 def faker_modules
-  FFaker.constants.sort.map do |const|
-    mod = FFaker.const_get(const)
-    next unless mod.is_a?(Module)
-    next if mod == FFaker::ArrayUtils
-    next if mod == FFaker::ModuleUtils
-    next if mod == FFaker::RandomUtils
-    next if mod == FFaker::Random
-    mod
-  end.compact
+  FFaker
+    .constants
+    .reject { |const| UTILS_MODULES.include?(const) }
+    .select { |const| FFaker.const_get(const).instance_of?(Module) }
+    .sort
+    .map { |const| FFaker.const_get(const) }
 end
 
 # Returns faker methods for a given module
 def faker_methods(mod)
-  methods = mod.methods - Module.methods -
-            %i[k underscore fetch_sample rand shuffle unique]
+  methods = mod.methods - Module.methods - UTILS_METHODS
 
   # For Company.name (et al), don't discard :name if it was reimplemented
   methods << :name if mod.send(:name) != mod.to_s
@@ -32,12 +36,14 @@ end
 # Catch deprecation warnings.
 # This `#warn` overrides Kernel#warn
 def warn(msg)
-  $warnings << msg if $warnings
+  return unless Kernel.instance_variable_get(:@ffaker_warnings)
+
+  Kernel.instance_variable_set(:@ffaker_warnings, Kernel.instance_variable_get(:@ffaker_warnings) << msg)
 end
 
 def catch_warnings
-  $warnings = []
-  [yield, $warnings]
+  Kernel.instance_variable_set(:@ffaker_warnings, [])
+  [yield, Kernel.instance_variable_get(:@ffaker_warnings)]
 end
 
 def escape(str)
@@ -59,19 +65,15 @@ sections = faker_modules.map do |mod|
     left = "`#{meth}`"
     right = ''
 
-    if arity > 0
+    if arity.positive?
       left = "`#{meth}`(#{Array.new(arity) { '...' }.join(', ')})"
     else
       begin
         examples, warnings = catch_warnings do
-          Array.new(3) { mod.send meth }
+          Array.new(3) { mod.unique.send meth }
         end
-        right = if warnings.any?
-                  "#{ICONS[:warning]} *#{warnings.first}*"
-                else
-                  (escape examples.join(', ')).to_s
-                end
-      rescue => e
+        right = warnings.any? ? "#{ICONS[:warning]} *#{warnings.first}*" : (escape examples.join(', ')).to_s
+      rescue StandardError => e
         right = "#{ICONS[:error]} #{e.class}: #{e.message}"
       end
     end

data/test/helper.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 require 'test/unit'
-require 'ffaker'
+require_relative '../lib/ffaker'
 
 # Helpers for checking if a method is deterministic -- e.g., that the Random
 # results are repeatable given the same random seed.
@@ -11,21 +13,54 @@ module DeterministicHelper
   # Accepts a block. Executes the block multiple times after resetting
   # the internal Random Number Generator state and compared the results of
   # each execution to make sure they are the same.
-  def assert_deterministic(options = {})
-    raise ArgumentError, 'Must pass a block' unless block_given?
+  def assert_deterministic(options = {}, &block)
+    raise ArgumentError, 'Must pass a block' unless block
 
     options = { message: 'Results are not repeatable' }.merge(options)
 
     returns = Array.new(2) do
       FFaker::Random.reset!
-      Array.new(5) do
-        yield
-      end
+      Array.new(5, &block)
     end
 
     assert(returns.uniq.length == 1, options[:message])
   end
 
+  %w[< > <= >=].each do |operator|
+    operator_name =
+      case operator[0]
+      when '<' then 'less_than'
+      when '>' then 'greater_than'
+      else raise 'Unexpected operator'
+      end
+    operator_name += '_or_equal_to' if operator[1] == '='
+
+    define_method "assert_#{operator_name}" do |got, expected|
+      assert(
+        got.public_send(operator, expected),
+        "Expected #{operator} \"#{expected}\", but got #{got}"
+      )
+    end
+  end
+
+  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)
+    100.times do
+      yield(*args)
+      assert_deterministic(&original_block)
+    end
+  end
+
+  %w[less_than_or_equal_to between].each do |method_name|
+    define_method "assert_random_#{method_name}" do |*args, &block|
+      assert_random(block) { send "assert_#{method_name}", block.call, *args }
+    end
+  end
+
   # Methods to be called outside of individual examples.
   module ClassMethods
     # Shorthand method to quickly test the determinability of multiple methods.

data/test/test_address.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-require 'helper'
+require_relative 'helper'
 
 class TestAddress < Test::Unit::TestCase
   include DeterministicHelper

data/test/test_address_au.rb

@@ -1,8 +1,7 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-require 'helper'
+require_relative 'helper'
 
-# Author: wiseleyb<wiseleyb@gmail.com>
 class TestAddressAU < Test::Unit::TestCase
   include DeterministicHelper
 
@@ -12,9 +11,9 @@ class TestAddressAU < Test::Unit::TestCase
   )
 
   def test_au_state_abbr_insertion
-    arr = FFaker::AddressAU::STATE_ABBR.sort
-    assert arr = FFaker::AddressAU::SUBURB.keys.sort
-    assert arr = FFaker::AddressAU::POSTCODE.keys.sort
+    FFaker::AddressAU::STATE_ABBR.sort
+    assert FFaker::AddressAU::SUBURB.keys.sort
+    assert FFaker::AddressAU::POSTCODE.keys.sort
   end
 
   def test_au_state
@@ -34,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
@@ -61,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

@@ -1,13 +1,13 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-require 'helper'
+require_relative 'helper'
 
 class TestAddressBR < Test::Unit::TestCase
   include DeterministicHelper
 
   assert_methods_are_deterministic(
     FFaker::AddressBR,
-    :zip_code, :state, :state_abbr, :city, :street_prefix, :street, :full_address
+    :zip_code, :state, :state_abbr, :city, :street_prefix, :street, :complement, :neighborhood, :full_address
   )
 
   def test_zip_code
@@ -32,6 +32,19 @@ 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(/\A(#{prefixes.join('|')})(?: [\p{Alpha}-]+)+\z/, FFaker::AddressBR.street)
+  end
+
+  def test_complement
+    assert_match(/\A(?:Apartamento \d{3}|Casa Térrea|Fundos)\z/, FFaker::AddressBR.complement)
+  end
+
+  def test_neighborhood
+    neighborhood_prefix = FFaker::AddressBR.neighborhood.split(' ').first
+    assert FFaker::AddressBR::NEIGHBORHOOD_PREFIXES.include?(neighborhood_prefix)
+  end
+
+  def test_full_address
+    assert_match(/\A[\p{Alpha}\d, -]+\z/, FFaker::AddressBR.full_address)
   end
 end

data/test/test_address_ca.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-require 'helper'
+require_relative 'helper'
 
 class TestAddressCA < Test::Unit::TestCase
   include DeterministicHelper

data/test/test_address_ch.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-require 'helper'
+require_relative 'helper'
 
 class TestAddressCHCH < Test::Unit::TestCase
   include DeterministicHelper

data/test/test_address_ch_de.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-require 'helper'
+require_relative 'helper'
 
 class TestAddressCHDE < Test::Unit::TestCase
   include DeterministicHelper

data/test/test_address_ch_fr.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-require 'helper'
+require_relative 'helper'
 
 class TestAddressCHFR < Test::Unit::TestCase
   include DeterministicHelper

data/test/test_address_ch_it.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-require 'helper'
+require_relative 'helper'
 
 class TestAddressCHIT < Test::Unit::TestCase
   include DeterministicHelper

data/test/test_address_da.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-require 'helper'
+require_relative 'helper'
 
 class TestAddressDA < Test::Unit::TestCase
   include DeterministicHelper
@@ -20,11 +20,11 @@ class TestAddressDA < Test::Unit::TestCase
   end
 
   def test_state
-    assert_match(/\A[-ÆØÅæøåa-z-]+\z/i, FFaker::AddressDA.state)
+    assert_match(/\A[-ÆØÅæøåa-z]+\z/i, FFaker::AddressDA.state)
   end
 
   def test_kommune
-    assert_match(/\A[-ÆØÅæøåa-z-]+\z/i, FFaker::AddressDA.kommune)
+    assert_match(/\A[-ÆØÅæøåa-z]+\z/i, FFaker::AddressDA.kommune)
   end
 
   def test_region
@@ -32,7 +32,7 @@ class TestAddressDA < Test::Unit::TestCase
   end
 
   def test_city
-    assert_match(/\A[- ÆØÅæøåla-z-]+\z/i, FFaker::AddressDA.city)
+    assert_match(/\A[- ÆØÅæøåla-z]+\z/i, FFaker::AddressDA.city)
   end
 
   def test_street_name

data/test/test_address_de.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-require 'helper'
+require_relative 'helper'
 
 class TestAddressDE < Test::Unit::TestCase
   include DeterministicHelper