ffakerer 1.0.1

data/lib/ffakerer/unit_metric.rb

@@ -0,0 +1,105 @@
+# encoding: utf-8
+
+require 'ffakerer/unit'
+require 'ostruct'
+
+module Faker
+  module UnitMetric
+    include Faker::Unit
+
+    extend ModuleUtils
+    extend self
+
+    def mass_name
+      mass.name
+    end
+
+    def mass_abbr
+      mass.abbreviation
+    end
+
+    def length_name
+      length.name
+    end
+
+    def length_abbr
+      length.abbreviation
+    end
+
+    def liquid_name
+      liquid.name
+    end
+
+    def liquid_abbr
+      liquid.abbreviation
+    end
+
+    def volume_name
+      volume.name
+    end
+
+    def volume_abbr
+      volume.abbreviation
+    end
+
+    def area_name
+      area.name
+    end
+
+    def area_abbr
+      area.abbreviation
+    end
+
+    private
+
+    def length
+      OpenStruct.new LENGTH_UNITS.rand
+    end
+
+    def mass
+      OpenStruct.new MASS_UNITS.rand
+    end
+
+    def liquid
+      OpenStruct.new LIQUID_UNITS.rand
+    end
+
+    def volume
+      OpenStruct.new VOLUME_UNITS.rand
+    end
+
+    def area
+      OpenStruct.new AREA_UNITS.rand
+    end
+
+    LENGTH_UNITS = k [
+      { :name =>"millimeters", :abbreviation => "mm"},
+      { :name =>"centimeters", :abbreviation => "cm"},
+      {  :name =>"meters", :abbreviation => "m"},
+      { :name =>"kilometers", :abbreviation => "km"}
+    ]
+
+    MASS_UNITS = k [
+      { :name => "gram", :abbreviation => "g"},
+      { :name => "kilogram", :abbreviation => "kg" },
+      { :name => "metric ton", :abbreviation => "mt"}
+    ]
+
+    LIQUID_UNITS = k [
+      { :name => "milliliters", :abbreviation => "ml"},
+      { :name => "liters", :abbreviation => "L"}
+    ]
+
+    VOLUME_UNITS = k [
+      { :name => " cubic centimeters", :abbreviation => "cm^3"},
+      { :name => "cubic meters", :abbreviation => "m^3"}
+    ]
+
+    AREA_UNITS = k [
+      { :name => "centimeters squared", :abbreviation => "cm^2"},
+      { :name => "meters squared", :abbreviation => "m^2"},
+      { :name => "hectares", :abbreviation => "ha"},
+      { :name => "kilometers", :abbreviation => "km" }
+    ]
+  end
+end

data/lib/ffakerer/utils/array_utils.rb

@@ -0,0 +1,44 @@
+module Faker
+  module ArrayUtils
+    def self.const_array(argument)
+      array = argument.is_a?(Array) ? argument : argument.to_a
+      array.extend ArrayUtils
+      freeze_all(array)
+    end
+
+    def self.random_pick(array, n)
+      indexes = (0...array.length).sort_by{Kernel.rand}[0...n]
+      indexes.map { |n| array[n].dup }
+    end
+
+    def self.rand(array)
+      array[Kernel.rand(array.length)].dup
+    end
+
+    def self.freeze_all(array)
+      array.each { |e| e.freeze }
+      array.freeze
+      array
+    end
+
+    def self.shuffle(array)
+      array.sort_by{Kernel.rand}
+    end
+
+    def random_pick(n)
+      ArrayUtils.random_pick(self, n)
+    end
+
+    def rand
+      ArrayUtils.rand(self)
+    end
+
+    def freeze_all
+      ArrayUtils.freeze_all(self)
+    end
+
+    def shuffle
+      ArrayUtils.shuffle(self)
+    end
+  end
+end

data/lib/ffakerer/utils/module_utils.rb

@@ -0,0 +1,29 @@
+require 'ffakerer/utils/array_utils'
+
+module Faker
+  module ModuleUtils
+    def k(arg)
+      Faker::ArrayUtils.const_array(arg)
+    end
+
+    def const_missing(const_name)
+      if const_name =~ /[a-z]/ # Not a constant, probably a class/module name.
+        super const_name
+      else
+        mod_name = ancestors.first.to_s.split("::").last
+        data_path = "#{Faker::BASE_LIB_PATH}/ffakerer/data/#{underscore(mod_name)}/#{underscore(const_name.to_s)}"
+        data = k File.read(data_path).split("\n")
+        const_set const_name, data
+        data
+      end
+    end
+
+    def underscore(string)
+      string.gsub(/::/, '/').
+      gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+      gsub(/([a-z\d])([A-Z])/,'\1_\2').
+      tr("-", "_").
+      downcase
+    end
+  end
+end

data/lib/ffakerer/venue.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+module Faker
+  module Venue
+    extend ModuleUtils
+    extend self
+
+    def name
+      VENUE_LIST.rand
+    end
+  end
+end

data/scripts/benchmark.rb

@@ -0,0 +1,21 @@
+require 'rubygems'
+require 'benchmark'
+
+N = 10_000
+
+def run(name)
+  require name
+  Benchmark.bm do |rep|
+    rep.report("generating #{ N } names (#{name} #{Faker::VERSION})") do
+      N.times do
+        Faker::Name.name
+      end
+    end
+  end
+  $stdout.flush
+  exit(0)
+end
+
+fork { run("faker") }; Process.wait
+fork { run("ffaker") }; Process.wait
+fork { run("ffakerer") }; Process.wait

data/scripts/profile.sh

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

data/scripts/profiling.rb

@@ -0,0 +1,7 @@
+require File.dirname(__FILE__) + '/../lib/faker'
+
+N = 1_000_000
+
+N.times do
+  Faker::Name.name
+end

data/test/helper.rb

@@ -0,0 +1,2 @@
+require 'test/unit'
+require 'ffaker'

data/test/test_address.rb

@@ -0,0 +1,73 @@
+# encoding: utf-8
+
+require 'helper'
+
+class TestAddress < Test::Unit::TestCase
+  def test_building_number
+    assert_match /\A\d{3,5}\z/, Faker::Address.building_number
+  end
+
+  def test_city
+    assert_match /[ a-z]+/, Faker::Address.city
+  end
+
+  def test_city_prefix
+    assert_match /[ a-z]/, Faker::Address.city_prefix
+  end
+
+  def test_city_suffix
+    assert_match /[ a-z]/, Faker::Address.city_suffix
+  end
+
+  def test_secondary_address
+    assert_match /[ a-z]/, Faker::Address.secondary_address
+  end
+
+  def test_street_address
+    assert_match /[ a-z]/, Faker::Address.street_address
+  end
+
+  def test_street_name
+    assert_match /[ a-z]/, Faker::Address.street_name
+  end
+
+  def test_street_suffix
+    assert_match /[ a-z]/, Faker::Address.street_suffix
+  end
+
+  def test_uk_country
+    assert_match /[ a-z]/, Faker::AddressUK.country
+  end
+
+  def test_uk_county
+    assert_match /[ a-z]/, Faker::AddressUK.county
+  end
+
+  def test_uk_postcode
+    assert_match /[ a-z]/, Faker::AddressUK.postcode
+  end
+
+  def test_us_state
+    assert_match /[ a-z]/, Faker::AddressUS.state
+  end
+
+  def test_us_state_abbr
+    assert_match /[A-Z]/, Faker::AddressUS.state_abbr
+  end
+
+  def test_zip_code
+    assert_match /[0-9]/, Faker::AddressUS.zip_code
+  end
+
+  def test_zip_code_frozen
+    assert Faker::AddressUS.zip_code.frozen? == false
+  end
+
+  def test_neighborhood
+    assert_match /[ a-z]+/, Faker::Address::neighborhood
+  end
+
+  def test_country
+    assert_match /[ a-z]+/, Faker::Address::country
+  end
+end

data/test/test_address_au.rb

@@ -0,0 +1,58 @@
+# encoding: utf-8
+
+require 'helper'
+
+# Author: wiseleyb<wiseleyb@gmail.com>
+class TestAddressAU < Test::Unit::TestCase
+
+  def test_au_state_abbr
+    arr = Faker::AddressAU::STATE_ABBR.sort
+    assert arr = Faker::AddressAU::SUBURB.keys.sort
+    assert arr = Faker::AddressAU::POSTCODE.keys.sort
+  end
+
+  def test_au_state
+    assert_match /[ a-z]/, Faker::AddressAU.state
+  end
+
+  def test_au_state_abbr
+    assert_match /[A-Z]/, Faker::AddressAU.state_abbr
+  end
+
+  def test_au_suburb
+    assert_match /[a-zA-Z]/, Faker::AddressAU.suburb
+  end
+
+  def test_postcode
+    assert_match /\d{4}/, Faker::AddressAU.postcode
+  end
+
+  def test_full_address
+    assert_match /[\, a-z]/, Faker::AddressAU.full_address
+  end
+
+  def test_au_suburb_with_states
+    Faker::AddressAU::STATE_ABBR.each do |st_abbr|
+      assert_match /[a-zA-Z]/, Faker::AddressAU.suburb(st_abbr)
+    end
+  end
+
+  def test_au_suburb_with_state_and_postcodes
+    Faker::AddressAU::STATE_ABBR.each do |st_abbr|
+      p_code = Faker::AddressAU.postcode(st_abbr)
+      assert_match /[a-zA-Z]/, Faker::AddressAU.suburb(st_abbr, p_code)
+    end
+  end
+
+  def test_postcode_with_states
+    Faker::AddressAU::STATE_ABBR.each do |st_abbr|
+      assert_match /\d{4}/, Faker::AddressAU.postcode(st_abbr)
+    end
+  end
+
+  def test_full_address_with_states
+    Faker::AddressAU::STATE_ABBR.each do |st_abbr|
+      assert_match /[\, a-z]/, Faker::AddressAU.full_address(st_abbr)
+    end
+  end
+end

data/test/test_address_ca.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+require 'helper'
+
+class TestAddressCA < Test::Unit::TestCase
+  def test_province
+    assert_match /[ a-z]/, Faker::AddressCA.province
+  end
+
+  def test_province_abbr
+    assert_match /[A-Z][A-Z]/, Faker::AddressCA.province_abbr
+  end
+
+  def test_postal_code
+    assert_match /[A-Z]\d[A-Z]\W\d[A-Z]\d/, Faker::AddressCA.postal_code
+  end
+end

data/test/test_address_de.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+require 'helper'
+
+class TestAddressDE < Test::Unit::TestCase
+  def test_city
+    assert_match /[ a-z]+/, Faker::AddressDE.city
+  end
+
+  def test_state
+    assert_match /[ a-z]/, Faker::AddressDE.state
+  end
+
+  def test_zip_code
+    assert_match /^\d{5}$/, Faker::AddressDE.zip_code
+  end
+
+  def test_street_name
+    assert_match /[ a-z]+/, Faker::AddressDE.street_name
+  end
+
+  def test_street_address
+    assert_match /[ a-z]+/, Faker::AddressDE.street_address
+  end
+end

data/test/test_address_mx.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+require 'helper'
+
+# Author: guapolo github.com/guapolo
+class TestAddressMX < Test::Unit::TestCase
+  def setup
+    @tester = Faker::AddressMX
+  end
+
+  def test_mx_state
+    assert_match /[ A-Za-z]/, @tester.state
+  end
+
+  def test_mx_state_abbr
+    assert_match /[A-Z]/, @tester.state_abbr
+  end
+
+  def test_postcode
+    assert_match /[0-9]/, @tester.zip_code
+  end
+
+  def test_mx_municipality
+    assert_match /[ a-z]/, @tester.municipality
+  end
+end

data/test/test_address_se.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+
+require 'helper'
+
+class TestAddressSE < Test::Unit::TestCase
+
+  ALPHA = /\A[[:alpha:]]+/
+  DIGIT = /\d{1}/
+
+  def test_se_city
+    assert_match ALPHA, Faker::AddressSE.city
+  end
+
+  def test_se_zip_code
+    assert_match(/\d{2}/, Faker::AddressSE.zip_code)
+  end
+
+  def test_countries
+    assert Faker::AddressSE::COUNTRIES.include?(Faker::AddressSE.random_country)
+  end
+
+  def test_se_full_address
+    address = Faker::AddressSE.full_address
+    assert_match ALPHA, address
+    assert_match DIGIT, address
+    assert_match(/SVERIGE/, address)
+  end
+
+  def test_se_zip_code_frozen
+    assert Faker::AddressSE.zip_code.frozen? == false
+  end
+
+  def test_se_full_address
+    assert_match(/[\, a-z]/, Faker::AddressSE.full_address)
+  end
+end