ffakerTW 0.1.0

data/scripts/reference.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require_relative '../lib/ffakerTW'
+require 'set'
+
+# always use the same seed for consistency
+FFakerTW::Random.seed = 1337
+
+ICONS = {
+  error: '‼️',
+  warning: '❗'
+}.freeze
+
+UTILS_MODULES = %i[ArrayUtils ModuleUtils RandomUtils Random]
+UTILS_METHODS = %i[k underscore fetch_sample rand shuffle unique luhn_check]
+
+# Get a list of sections
+def faker_modules
+  FFakerTW
+    .constants
+    .reject { |const| UTILS_MODULES.include?(const) }
+    .select { |const| FFakerTW.const_get(const).instance_of?(Module) }
+    .sort
+    .map { |const| FFakerTW.const_get(const) }
+end
+
+# Returns faker methods for a given module
+def faker_methods(mod)
+  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
+  methods
+end
+
+# Catch deprecation warnings.
+# This `#warn` overrides Kernel#warn
+def warn(msg)
+  $warnings << msg if $warnings
+end
+
+def catch_warnings
+  $warnings = []
+  [yield, $warnings]
+end
+
+def escape(str)
+  str.gsub('&', '&amp;').gsub('<', '&lt;').gsub('>', '&gt;').delete("\n")
+end
+
+sections = faker_modules.map do |mod|
+  lines = []
+
+  methods = faker_methods(mod)
+  lines << "## #{mod}"
+  lines << ''
+  lines << '| Method | Example |'
+  lines << '| ------ | ------- |'
+
+  methods.sort.each do |meth|
+    arity = mod.method(meth).arity
+
+    left = "`#{meth}`"
+    right = ''
+
+    if arity.positive?
+      left = "`#{meth}`(#{Array.new(arity) { '...' }.join(', ')})"
+    else
+      begin
+        examples, warnings = catch_warnings do
+          Array.new(3) { mod.unique.send meth }
+        end
+        right = if warnings.any?
+                  "#{ICONS[:warning]} *#{warnings.first}*"
+                else
+                  (escape examples.join(', ')).to_s
+                end
+      rescue StandardError => e
+        right = "#{ICONS[:error]} #{e.class}: #{e.message}"
+      end
+    end
+
+    lines << "| #{left} | #{right} |"
+  end
+
+  lines << ''
+end
+
+puts '# FFakerTW reference'
+puts ''
+faker_modules.each do |mod|
+  name = mod.to_s.downcase.delete(':')
+  puts " * [#{mod}](##{name})"
+end
+puts ''
+puts sections.flatten.join("\n")

data/test/helper.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'test/unit'
+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.
+module DeterministicHelper
+  def self.included(base)
+    base.extend ClassMethods
+  end
+
+  # 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?
+
+    options = { message: 'Results are not repeatable' }.merge(options)
+
+    returns = Array.new(2) do
+      FFakerTW::Random.reset!
+      Array.new(5) do
+        yield
+      end
+    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.
+    #
+    #  assert_methods_are_deterministic(
+    #    <faker module under test>,
+    #    <method names to test, as array of symbols>
+    #  )
+    #
+    #  assert_methods_are_deterministic(
+    #    FFakerTW::SomeModule,
+    #    :some_method, :some_other_method
+    #  }
+    def assert_methods_are_deterministic(klass, *methods)
+      Array(methods).each do |meth|
+        define_method "test_#{meth}_is_deterministic" do
+          assert_deterministic(message: "Results from `#{klass}.#{meth}` are not repeatable") do
+            klass.send(meth)
+          end
+        end
+      end
+    end
+  end
+end

data/test/test_address.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestAddress < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::Address,
+    :building_number, :city, :city_prefix, :city_suffix, :secondary_address,
+    :street_address, :street_name, :street_suffix, :neighborhood,
+    :country, :country_code, :time_zone
+  )
+
+  assert_methods_are_deterministic(
+    FFakerTW::AddressUS,
+    :state, :state_abbr, :zip_code
+  )
+
+  def test_building_number
+    assert_match(/\A\d{3,5}\z/, FFakerTW::Address.building_number)
+  end
+
+  def test_city
+    assert_match(/[ a-z]+/, FFakerTW::Address.city)
+  end
+
+  def test_city_prefix
+    assert_match(/[ a-z]/, FFakerTW::Address.city_prefix)
+  end
+
+  def test_city_suffix
+    assert_match(/[ a-z]/, FFakerTW::Address.city_suffix)
+  end
+
+  def test_secondary_address
+    assert_match(/[ a-z]/, FFakerTW::Address.secondary_address)
+  end
+
+  def test_street_address
+    assert_match(/[ a-z]/, FFakerTW::Address.street_address)
+  end
+
+  def test_street_name
+    assert_match(/[ a-z]/, FFakerTW::Address.street_name)
+  end
+
+  def test_street_suffix
+    assert_match(/[ a-z]/, FFakerTW::Address.street_suffix)
+  end
+
+  def test_uk_country
+    assert_match(/[ a-z]/, FFakerTW::AddressUK.country)
+    assert_deterministic { FFakerTW::AddressUK.country }
+  end
+
+  def test_uk_county
+    assert_match(/[ a-z]/, FFakerTW::AddressUK.county)
+    assert_deterministic { FFakerTW::AddressUK.county }
+  end
+
+  def test_uk_postcode
+    assert_match(/[ a-z]/, FFakerTW::AddressUK.postcode)
+    assert_deterministic { FFakerTW::AddressUK.postcode }
+  end
+
+  def test_us_state
+    assert_match(/[ a-z]/, FFakerTW::AddressUS.state)
+  end
+
+  def test_us_state_abbr
+    assert_match(/[A-Z]/, FFakerTW::AddressUS.state_abbr)
+  end
+
+  def test_zip_code
+    assert_match(/[0-9]/, FFakerTW::AddressUS.zip_code)
+  end
+
+  def test_zip_code_frozen
+    assert FFakerTW::AddressUS.zip_code.frozen? == false
+  end
+
+  def test_neighborhood
+    assert_match(/[ a-z]+/, FFakerTW::Address.neighborhood)
+  end
+
+  def test_country
+    assert_match(/[ a-z]+/, FFakerTW::Address.country)
+  end
+
+  def test_country_by_county_code
+    assert_match('Ukraine', FFakerTW::Address.country('UA'))
+    assert_deterministic { FFakerTW::Address.country('UA') }
+  end
+
+  def test_country_code
+    assert_match(/[A-Z]{2}/, FFakerTW::Address.country_code)
+  end
+
+  def test_country_code_of_particular_country
+    assert_match('UA', FFakerTW::Address.country_code('Ukraine'))
+    assert_match(/[A-Z]{2}/, FFakerTW::Address.country_code('Foo'))
+    assert_deterministic { FFakerTW::Address.country_code('Ukraine') }
+  end
+
+  def test_time_zone
+    assert_include FFakerTW::Address::TIME_ZONE, FFakerTW::Address.time_zone
+  end
+end

data/test/test_address_au.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestAddressAU < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::AddressAU,
+    :state, :state_abbr, :suburb, :postcode, :full_address
+  )
+
+  def test_au_state_abbr_insertion
+    FFakerTW::AddressAU::STATE_ABBR.sort
+    assert FFakerTW::AddressAU::SUBURB.keys.sort
+    assert FFakerTW::AddressAU::POSTCODE.keys.sort
+  end
+
+  def test_au_state
+    assert_match(/[ a-z]/, FFakerTW::AddressAU.state)
+  end
+
+  def test_au_state_abbr
+    assert_match(/[A-Z]/, FFakerTW::AddressAU.state_abbr)
+  end
+
+  def test_au_suburb
+    assert_match(/[a-zA-Z]/, FFakerTW::AddressAU.suburb)
+  end
+
+  def test_postcode
+    assert_match(/\d{4}/, FFakerTW::AddressAU.postcode)
+  end
+
+  def test_full_address
+    assert_match(/[, a-z]/, FFakerTW::AddressAU.full_address)
+  end
+
+  def test_au_suburb_with_states
+    FFakerTW::AddressAU::STATE_ABBR.each do |st_abbr|
+      assert_match(/[a-zA-Z]/, FFakerTW::AddressAU.suburb(st_abbr))
+      assert_deterministic { FFakerTW::AddressAU.suburb(st_abbr) }
+    end
+  end
+
+  def test_au_suburb_with_state_and_postcodes
+    FFakerTW::AddressAU::STATE_ABBR.each do |st_abbr|
+      p_code = FFakerTW::AddressAU.postcode(st_abbr)
+      assert_match(/[a-zA-Z]/, FFakerTW::AddressAU.suburb(st_abbr, p_code))
+      assert_deterministic { FFakerTW::AddressAU.suburb(st_abbr, p_code) }
+    end
+  end
+
+  def test_postcode_with_states
+    FFakerTW::AddressAU::STATE_ABBR.each do |st_abbr|
+      assert_match(/\d{4}/, FFakerTW::AddressAU.postcode(st_abbr))
+      assert_deterministic { FFakerTW::AddressAU.postcode(st_abbr) }
+    end
+  end
+
+  def test_full_address_with_states
+    FFakerTW::AddressAU::STATE_ABBR.each do |st_abbr|
+      assert_match(/[, a-z]/, FFakerTW::AddressAU.full_address(st_abbr))
+      assert_deterministic { FFakerTW::AddressAU.full_address(st_abbr) }
+    end
+  end
+
+  def test_time_zone
+    assert_includes(FFakerTW::AddressAU::TIME_ZONE.values, FFakerTW::AddressAU.time_zone)
+  end
+
+  def test_time_zone_with_states
+    FFakerTW::AddressAU::STATE_ABBR.each do |st_abbr|
+      assert_includes(FFakerTW::AddressAU::TIME_ZONE.values, FFakerTW::AddressAU.time_zone)
+      assert_deterministic { FFakerTW::AddressAU.postcode(st_abbr) }
+    end
+  end
+end

data/test/test_address_br.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestAddressBR < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::AddressBR,
+    :zip_code, :state, :state_abbr, :city, :street_prefix, :street, :complement, :neighborhood, :full_address
+  )
+
+  def test_zip_code
+    assert_match(/\d{5}-\d{3}/, FFakerTW::AddressBR.zip_code)
+  end
+
+  def test_state
+    assert FFakerTW::AddressBR::STATE.include?(FFakerTW::AddressBR.state)
+  end
+
+  def test_state_abbr
+    assert FFakerTW::AddressBR::STATE_ABBR.include?(FFakerTW::AddressBR.state_abbr)
+  end
+
+  def test_city
+    assert FFakerTW::AddressBR::CITY.include?(FFakerTW::AddressBR.city)
+  end
+
+  def test_street_prefix
+    assert FFakerTW::AddressBR::STREET_PREFIX.include?(FFakerTW::AddressBR.street_prefix)
+  end
+
+  def test_street
+    prefixes = FFakerTW::AddressBR::STREET_PREFIX
+    assert_match(/\A(#{prefixes.join('|')})(?: [\p{Alpha}-]+)+\z/, FFakerTW::AddressBR.street)
+  end
+
+  def test_complement
+    assert_match(/\A(?:Apartamento \d{3}|Casa Térrea|Fundos)\z/, FFakerTW::AddressBR.complement)
+  end
+
+  def test_neighborhood
+    neighborhood_prefix = FFakerTW::AddressBR.neighborhood.split(' ').first
+    assert FFakerTW::AddressBR::NEIGHBORHOOD_PREFIXES.include?(neighborhood_prefix)
+  end
+
+  def test_full_address
+    assert_match(/\A[\p{Alpha}\d, -]+\z/, FFakerTW::AddressBR.full_address)
+  end
+end

data/test/test_address_ca.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestAddressCA < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::AddressCA,
+    :province, :province_abbr, :city, :postal_code
+  )
+
+  def test_province
+    assert_match(/\A[ a-z]+\z/i, FFakerTW::AddressCA.province)
+  end
+
+  def test_province_abbr
+    assert_match(/\A[A-Z]{2}\z/, FFakerTW::AddressCA.province_abbr)
+  end
+
+  def test_city
+    assert_include(FFakerTW::AddressCA::CITY, FFakerTW::AddressCA.city)
+  end
+
+  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/,
+      FFakerTW::AddressCA.postal_code
+    )
+  end
+end

data/test/test_address_ch.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestAddressCHCH < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFakerTW::AddressCH, :canton_abbr, :postal_code)
+
+  def test_ch_canton_abbr
+    assert_match(/\A[A-Z]{2}\z/, FFakerTW::AddressCH.canton_abbr)
+  end
+
+  def test_postal_code
+    assert_match(/\A\d{4}\z/, FFakerTW::AddressCH.postal_code)
+  end
+end

data/test/test_address_ch_de.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestAddressCHDE < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFakerTW::AddressCHDE, :canton)
+
+  def test_ch_de_canton
+    assert_match(/\A[-. a-zæøåü]+\z/i, FFakerTW::AddressCHDE.canton)
+  end
+end

data/test/test_address_ch_fr.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestAddressCHFR < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFakerTW::AddressCHFR, :canton)
+
+  def test_ch_fr_canton
+    assert_match(/\A[- a-zàâäèéêëîïôœùûüÿç]+\z/i, FFakerTW::AddressCHFR.canton)
+  end
+end

data/test/test_address_ch_it.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestAddressCHIT < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFakerTW::AddressCHIT, :canton)
+
+  def test_ch_it_canton
+    FFakerTW::AddressCHIT::CANTON.each do |canton|
+      assert_match(/\A[- a-zàâ]+\z/i, canton)
+    end
+  end
+end

data/test/test_address_da.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestAddressDA < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::AddressDA,
+    :city, :full_address, :kommune, :post_nr, :region, :state, :street_address,
+    :street_name, :zip_code
+  )
+
+  def test_zip_code
+    assert_match(/\A\d{4}\z/, FFakerTW::AddressDA.zip_code)
+  end
+
+  def test_post_nr
+    assert_match(/\A\d{4}\z/, FFakerTW::AddressDA.post_nr)
+  end
+
+  def test_state
+    assert_match(/\A[-ÆØÅæøåa-z-]+\z/i, FFakerTW::AddressDA.state)
+  end
+
+  def test_kommune
+    assert_match(/\A[-ÆØÅæøåa-z-]+\z/i, FFakerTW::AddressDA.kommune)
+  end
+
+  def test_region
+    assert_match(/\A[ÆØÅæøåa-z-]+\z/i, FFakerTW::AddressDA.region)
+  end
+
+  def test_city
+    assert_match(/\A[- ÆØÅæøåla-z-]+\z/i, FFakerTW::AddressDA.city)
+  end
+
+  def test_street_name
+    assert_match(/\A[. éÆØÅæøåla-z0-9-]+\z/i, FFakerTW::AddressDA.street_name)
+  end
+
+  def test_street_address
+    assert_match(/\A[. éÆØÅæøåla-z0-9-]+\z/i, FFakerTW::AddressDA.street_address)
+  end
+
+  def test_full_address
+    assert_match(/\A[. éÆØÅæøåla-z0-9-]+ DANMARK\z/i,
+                 FFakerTW::AddressDA.full_address)
+  end
+end

data/test/test_address_de.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestAddressDE < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::AddressDE,
+    :city, :state, :street_address, :street_name, :zip_code
+  )
+
+  def test_city
+    assert_match(/[ a-z]+/, FFakerTW::AddressDE.city)
+  end
+
+  def test_state
+    assert_match(/[ a-z]/, FFakerTW::AddressDE.state)
+  end
+
+  def test_zip_code
+    assert_match(/^\d{5}$/, FFakerTW::AddressDE.zip_code)
+  end
+
+  def test_street_name
+    assert_match(/[ a-z]+/, FFakerTW::AddressDE.street_name)
+  end
+
+  def test_street_address
+    assert_match(/[ a-z]+/, FFakerTW::AddressDE.street_address)
+  end
+end

data/test/test_address_fi.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestAddressFI < Test::Unit::TestCase
+  include DeterministicHelper
+
+  ALPHA = /\A\p{Alpha}+/.freeze
+  DIGIT = /\d{1}/.freeze
+
+  assert_methods_are_deterministic(
+    FFakerTW::AddressFI,
+    :city, :full_address, :random_country, :zip_code
+  )
+
+  def test_fi_city
+    assert_match(ALPHA, FFakerTW::AddressFI.city)
+  end
+
+  def test_fi_zip_code
+    assert_match(/\d{2}/, FFakerTW::AddressFI.zip_code)
+  end
+
+  def test_countries
+    assert FFakerTW::AddressFI::COUNTRIES.include?(FFakerTW::AddressFI.random_country)
+  end
+
+  def test_fi_full_address
+    address = FFakerTW::AddressFI.full_address
+    assert_match(ALPHA, address)
+    assert_match(DIGIT, address)
+    assert_match(/SUOMI/, address)
+    assert_match(/[, a-z]/, address)
+  end
+
+  def test_fi_zip_code_frozen
+    assert FFakerTW::AddressFI.zip_code.frozen? == false
+  end
+end

data/test/test_address_fr.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestAddressFR < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::AddressFR,
+    :city, :full_address, :street_name, :postal_code, :region
+  )
+end

data/test/test_address_gr.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestAddressGR < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::AddressGR,
+    :city, :region, :zip_code, :street_name, :street_nbr, :street_address
+  )
+
+  def setup
+    @address_gr = FFakerTW::AddressGR
+    @street_prefix = FFakerTW::AddressGR::STREET_PREFIX.join('|')
+  end
+
+  def test_city
+    assert_match(/\p{Greek}/, @address_gr.city)
+  end
+
+  def test_region
+    assert_match(/\p{Greek}/, @address_gr.region)
+  end
+
+  def test_zip_code
+    assert_match(/\A\d{5}\z/, @address_gr.zip_code)
+  end
+
+  def test_street_name
+    assert_match(/\p{Greek}/, @address_gr.street_name)
+  end
+
+  def test_street_nbr
+    assert_match(/\A\d{1,3}\z/, @address_gr.street_nbr)
+  end
+
+  def test_street_address
+    address = FFakerTW::AddressGR.street_address
+    assert_match(/#{@street_prefix}/, address)
+    assert_match(/\p{Greek}/, address)
+  end
+end