mini-fast-rb 0.0.1

data/ffaker-2.25.0/scripts/benchmark.rb

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

data/ffaker-2.25.0/scripts/profile.sh

@@ -0,0 +1,2 @@
+#!/bin/sh
+ruby-prof -pcall_tree -fprofile.data profiling.rb

data/ffaker-2.25.0/scripts/profiling.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative '../lib/faker'
+
+N = 1_000_000
+
+N.times do
+  FFaker::Name.name
+end

data/ffaker-2.25.0/scripts/reference.rb

@@ -0,0 +1,94 @@
+# 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
+    .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 - 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)
+  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
+  Kernel.instance_variable_set(:@ffaker_warnings, [])
+  [yield, Kernel.instance_variable_get(:@ffaker_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 = warnings.any? ? "#{ICONS[:warning]} *#{warnings.first}*" : (escape examples.join(', ')).to_s
+      rescue StandardError => e
+        right = "#{ICONS[:error]} #{e.class}: #{e.message}"
+      end
+    end
+
+    lines << "| #{left} | #{right} |"
+  end
+
+  lines << ''
+end
+
+puts '# FFaker reference'
+puts ''
+faker_modules.each do |mod|
+  name = mod.to_s.downcase.delete(':')
+  puts " * [#{mod}](##{name})"
+end
+puts ''
+puts sections.flatten.join("\n")

data/ffaker-2.25.0/test/helper.rb

@@ -0,0 +1,87 @@
+# 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 = {}, &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, &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.
+    #
+    #  assert_methods_are_deterministic(
+    #    <faker module under test>,
+    #    <method names to test, as array of symbols>
+    #  )
+    #
+    #  assert_methods_are_deterministic(
+    #    FFaker::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/ffaker-2.25.0/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(
+    FFaker::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(
+    FFaker::AddressUS,
+    :state, :state_abbr, :zip_code
+  )
+
+  def test_building_number
+    assert_match(/\A\d{3,5}\z/, FFaker::Address.building_number)
+  end
+
+  def test_city
+    assert_match(/[ a-z]+/, FFaker::Address.city)
+  end
+
+  def test_city_prefix
+    assert_match(/[ a-z]/, FFaker::Address.city_prefix)
+  end
+
+  def test_city_suffix
+    assert_match(/[ a-z]/, FFaker::Address.city_suffix)
+  end
+
+  def test_secondary_address
+    assert_match(/[ a-z]/, FFaker::Address.secondary_address)
+  end
+
+  def test_street_address
+    assert_match(/[ a-z]/, FFaker::Address.street_address)
+  end
+
+  def test_street_name
+    assert_match(/[ a-z]/, FFaker::Address.street_name)
+  end
+
+  def test_street_suffix
+    assert_match(/[ a-z]/, FFaker::Address.street_suffix)
+  end
+
+  def test_uk_country
+    assert_match(/[ a-z]/, FFaker::AddressUK.country)
+    assert_deterministic { FFaker::AddressUK.country }
+  end
+
+  def test_uk_county
+    assert_match(/[ a-z]/, FFaker::AddressUK.county)
+    assert_deterministic { FFaker::AddressUK.county }
+  end
+
+  def test_uk_postcode
+    assert_match(/[ a-z]/, FFaker::AddressUK.postcode)
+    assert_deterministic { FFaker::AddressUK.postcode }
+  end
+
+  def test_us_state
+    assert_match(/[ a-z]/, FFaker::AddressUS.state)
+  end
+
+  def test_us_state_abbr
+    assert_match(/[A-Z]/, FFaker::AddressUS.state_abbr)
+  end
+
+  def test_zip_code
+    assert_match(/[0-9]/, FFaker::AddressUS.zip_code)
+  end
+
+  def test_zip_code_frozen
+    assert FFaker::AddressUS.zip_code.frozen? == false
+  end
+
+  def test_neighborhood
+    assert_match(/[ a-z]+/, FFaker::Address.neighborhood)
+  end
+
+  def test_country
+    assert_match(/[ a-z]+/, FFaker::Address.country)
+  end
+
+  def test_country_by_county_code
+    assert_match('Ukraine', FFaker::Address.country('UA'))
+    assert_deterministic { FFaker::Address.country('UA') }
+  end
+
+  def test_country_code
+    assert_match(/[A-Z]{2}/, FFaker::Address.country_code)
+  end
+
+  def test_country_code_of_particular_country
+    assert_match('UA', FFaker::Address.country_code('Ukraine'))
+    assert_match(/[A-Z]{2}/, FFaker::Address.country_code('Foo'))
+    assert_deterministic { FFaker::Address.country_code('Ukraine') }
+  end
+
+  def test_time_zone
+    assert_include FFaker::Address::TIME_ZONE, FFaker::Address.time_zone
+  end
+end

data/ffaker-2.25.0/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(
+    FFaker::AddressAU,
+    :state, :state_abbr, :suburb, :postcode, :full_address
+  )
+
+  def test_au_state_abbr_insertion
+    FFaker::AddressAU::STATE_ABBR.sort
+    assert FFaker::AddressAU::SUBURB.keys.sort
+    assert FFaker::AddressAU::POSTCODE.keys.sort
+  end
+
+  def test_au_state
+    assert_match(/[ a-z]/, FFaker::AddressAU.state)
+  end
+
+  def test_au_state_abbr
+    assert_match(/[A-Z]/, FFaker::AddressAU.state_abbr)
+  end
+
+  def test_au_suburb
+    assert_match(/[a-zA-Z]/, FFaker::AddressAU.suburb)
+  end
+
+  def test_postcode
+    assert_match(/\d{4}/, FFaker::AddressAU.postcode)
+  end
+
+  def test_full_address
+    assert_match(/[, a-z]/, FFaker::AddressAU.full_address)
+  end
+
+  def test_au_suburb_with_states
+    FFaker::AddressAU::STATE_ABBR.each do |st_abbr|
+      assert_match(/[a-zA-Z]/, FFaker::AddressAU.suburb(st_abbr))
+      assert_deterministic { FFaker::AddressAU.suburb(st_abbr) }
+    end
+  end
+
+  def test_au_suburb_with_state_and_postcodes
+    FFaker::AddressAU::STATE_ABBR.each do |st_abbr|
+      p_code = FFaker::AddressAU.postcode(st_abbr)
+      assert_match(/[a-zA-Z]/, FFaker::AddressAU.suburb(st_abbr, p_code))
+      assert_deterministic { FFaker::AddressAU.suburb(st_abbr, p_code) }
+    end
+  end
+
+  def test_postcode_with_states
+    FFaker::AddressAU::STATE_ABBR.each do |st_abbr|
+      assert_match(/\d{4}/, FFaker::AddressAU.postcode(st_abbr))
+      assert_deterministic { FFaker::AddressAU.postcode(st_abbr) }
+    end
+  end
+
+  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_deterministic { FFaker::AddressAU.full_address(st_abbr) }
+    end
+  end
+
+  def test_time_zone
+    assert_includes(FFaker::AddressAU::TIME_ZONE.values, FFaker::AddressAU.time_zone)
+  end
+
+  def test_time_zone_with_states
+    FFaker::AddressAU::STATE_ABBR.each do |st_abbr|
+      assert_includes(FFaker::AddressAU::TIME_ZONE.values, FFaker::AddressAU.time_zone)
+      assert_deterministic { FFaker::AddressAU.postcode(st_abbr) }
+    end
+  end
+end

data/ffaker-2.25.0/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(
+    FFaker::AddressBR,
+    :zip_code, :state, :state_abbr, :city, :street_prefix, :street, :complement, :neighborhood, :full_address
+  )
+
+  def test_zip_code
+    assert_match(/\d{5}-\d{3}/, FFaker::AddressBR.zip_code)
+  end
+
+  def test_state
+    assert FFaker::AddressBR::STATE.include?(FFaker::AddressBR.state)
+  end
+
+  def test_state_abbr
+    assert FFaker::AddressBR::STATE_ABBR.include?(FFaker::AddressBR.state_abbr)
+  end
+
+  def test_city
+    assert FFaker::AddressBR::CITY.include?(FFaker::AddressBR.city)
+  end
+
+  def test_street_prefix
+    assert FFaker::AddressBR::STREET_PREFIX.include?(FFaker::AddressBR.street_prefix)
+  end
+
+  def test_street
+    prefixes = FFaker::AddressBR::STREET_PREFIX
+    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/ffaker-2.25.0/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(
+    FFaker::AddressCA,
+    :province, :province_abbr, :city, :postal_code
+  )
+
+  def test_province
+    assert_match(/\A[ a-z]+\z/i, FFaker::AddressCA.province)
+  end
+
+  def test_province_abbr
+    assert_match(/\A[A-Z]{2}\z/, FFaker::AddressCA.province_abbr)
+  end
+
+  def test_city
+    assert_include(FFaker::AddressCA::CITY, FFaker::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/,
+      FFaker::AddressCA.postal_code
+    )
+  end
+end

data/ffaker-2.25.0/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(FFaker::AddressCH, :canton_abbr, :postal_code)
+
+  def test_ch_canton_abbr
+    assert_match(/\A[A-Z]{2}\z/, FFaker::AddressCH.canton_abbr)
+  end
+
+  def test_postal_code
+    assert_match(/\A\d{4}\z/, FFaker::AddressCH.postal_code)
+  end
+end

data/ffaker-2.25.0/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(FFaker::AddressCHDE, :canton)
+
+  def test_ch_de_canton
+    assert_match(/\A[-. a-zæøåü]+\z/i, FFaker::AddressCHDE.canton)
+  end
+end

data/ffaker-2.25.0/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(FFaker::AddressCHFR, :canton)
+
+  def test_ch_fr_canton
+    assert_match(/\A[- a-zàâäèéêëîïôœùûüÿç]+\z/i, FFaker::AddressCHFR.canton)
+  end
+end

data/ffaker-2.25.0/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(FFaker::AddressCHIT, :canton)
+
+  def test_ch_it_canton
+    FFaker::AddressCHIT::CANTON.each do |canton|
+      assert_match(/\A[- a-zàâ]+\z/i, canton)
+    end
+  end
+end

data/ffaker-2.25.0/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(
+    FFaker::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/, FFaker::AddressDA.zip_code)
+  end
+
+  def test_post_nr
+    assert_match(/\A\d{4}\z/, FFaker::AddressDA.post_nr)
+  end
+
+  def test_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)
+  end
+
+  def test_region
+    assert_match(/\A[ÆØÅæøåa-z-]+\z/i, FFaker::AddressDA.region)
+  end
+
+  def test_city
+    assert_match(/\A[- ÆØÅæøåla-z]+\z/i, FFaker::AddressDA.city)
+  end
+
+  def test_street_name
+    assert_match(/\A[. éÆØÅæøåla-z0-9-]+\z/i, FFaker::AddressDA.street_name)
+  end
+
+  def test_street_address
+    assert_match(/\A[. éÆØÅæøåla-z0-9-]+\z/i, FFaker::AddressDA.street_address)
+  end
+
+  def test_full_address
+    assert_match(/\A[. éÆØÅæøåla-z0-9-]+ DANMARK\z/i,
+                 FFaker::AddressDA.full_address)
+  end
+end

data/ffaker-2.25.0/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(
+    FFaker::AddressDE,
+    :city, :state, :street_address, :street_name, :zip_code
+  )
+
+  def test_city
+    assert_match(/[ a-z]+/, FFaker::AddressDE.city)
+  end
+
+  def test_state
+    assert_match(/[ a-z]/, FFaker::AddressDE.state)
+  end
+
+  def test_zip_code
+    assert_match(/^\d{5}$/, FFaker::AddressDE.zip_code)
+  end
+
+  def test_street_name
+    assert_match(/[ a-z]+/, FFaker::AddressDE.street_name)
+  end
+
+  def test_street_address
+    assert_match(/[ a-z]+/, FFaker::AddressDE.street_address)
+  end
+end

data/ffaker-2.25.0/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}+/
+  DIGIT = /\d{1}/
+
+  assert_methods_are_deterministic(
+    FFaker::AddressFI,
+    :city, :full_address, :random_country, :zip_code
+  )
+
+  def test_fi_city
+    assert_match(ALPHA, FFaker::AddressFI.city)
+  end
+
+  def test_fi_zip_code
+    assert_match(/\d{2}/, FFaker::AddressFI.zip_code)
+  end
+
+  def test_countries
+    assert FFaker::AddressFI::COUNTRIES.include?(FFaker::AddressFI.random_country)
+  end
+
+  def test_fi_full_address
+    address = FFaker::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 FFaker::AddressFI.zip_code.frozen? == false
+  end
+end

data/ffaker-2.25.0/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(
+    FFaker::AddressFR,
+    :city, :full_address, :street_name, :postal_code, :region
+  )
+end