ffakerer 1.0.1

data/lib/ffakerer/product.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+module Faker
+  module Product
+    extend ModuleUtils
+    extend self
+
+    def brand
+      case rand(12)
+      when (0..4) then B1.rand + B2.rand
+      when (5..10) then "#{START.rand}#{VOWELS.rand}#{SUFFIX.rand}#{ADDON.rand if rand(2)==0}".capitalize
+      when 11 then "#{letters(2..3)}"
+      end
+    end
+
+    def product_name
+      case rand(2)
+      when 0 then "#{ADJ.rand} #{NOUN.rand}"
+      when 1 then "#{[ADJ.rand, ADJ.rand].uniq.join(" ")} #{NOUN.rand}"
+      end
+    end
+
+    def product
+      "#{brand} #{product_name}"
+    end
+
+    def letters(n)
+      max = n.is_a?(Range) ? n.to_a.shuffle.first : n
+      (0...max).map { LETTERS.rand.upcase }.join
+    end
+
+    def model
+      case rand(2)
+      when 0 then "#{LETTERS.rand.upcase}#{rand(90)}"   # N90
+      when 1 then "#{letters(1..rand(1..2))}-#{rand(9900)}"         # N-9400
+      end
+    end
+
+    B2   = k %w(nix cell sync func balt sche pod)
+    VOWELS = k %w(a e i o u ou ie y io)
+    START  = k %w(tr br p ph)
+    SUFFIX = k %w(ck ns nce nt st ne re ffe ph)
+    ADDON  = k %w(wood forge func)
+  end
+end

data/lib/ffakerer/skill.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+module Faker
+  module Skill
+    extend ModuleUtils
+    extend self
+
+    def tech_skill
+      TECH_SKILLS.rand
+    end
+
+    def tech_skills(num = 3)
+      TECH_SKILLS.random_pick(num) 
+    end
+
+    def specialty
+      "%s %s" % [SPECIALTY_START.rand, SPECIALTY_END.rand]
+    end
+
+    def specialties(num = 3)
+      (1..num).map { specialty }
+    end
+  end
+end

data/lib/ffakerer/ssn.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+module Faker
+  module SSN
+    extend ModuleUtils
+    extend self
+
+    # The Social Security number is a nine-digit number in the format
+    # "AAA-GG-SSSS". More info here:
+    #
+    # http://en.wikipedia.org/wiki/Social_Security_number
+    #
+    def ssn
+      Faker.numerify('###-##-####')
+    end
+  end
+end

data/lib/ffakerer/ssn_se.rb

@@ -0,0 +1,109 @@
+# encoding: utf-8
+
+require 'date'
+
+module Faker
+
+  # The Social Security number is a 12-digit number in the format:
+  # "YYYYDDMM-XXXX'
+  #
+  # http://sv.wikipedia.org/wiki/Personnummer_i_Sverige
+  #
+  # The 4 last digits (XXXX) are generated based on what region the person are
+  # born # in, the gender and the last one is a check digit using the luhn
+  # algorithm.
+  #
+  # http://en.wikipedia.org/wiki/Luhn_algorithm
+  #
+  # Usage:
+  # ssn(from: Time.local(1980, 2, 28),
+  #     to: Time.local(2000, 2, 28),
+  #     gender: :male)
+  #
+  module SSNSE
+    extend ModuleUtils
+    extend self
+
+    def ssn(opts = {})
+      from   = opts[:from]   || ::Time.local(1940, 1, 1)
+      to     = opts[:to]     || ::Time.now
+      gender = (opts[:gender] || GENDERS.rand).to_s
+
+      raise_error_on_bad_arguments(from, to, gender)
+
+      generate_ssn(from, to, gender)
+    end
+
+    private
+
+    def generate_ssn(from, to, gender)
+      birth_date = random_birth_time_between(from, to)
+      birth_date_str = birth_date.strftime("%Y%m%d")      # "19800228"
+      region = get_random_region_for(gender)              # "413"
+      ssn_without_check_digit = birth_date_str + region   # "19800228413"
+      check_digit = luhn_check(ssn_without_check_digit)   # "9"
+      ssn_without_check_digit + check_digit               # "198002284139"
+    end
+
+    def raise_error_on_bad_arguments(from, to, gender)
+      raise ArgumentError, "Invalid from argument: from" unless to.is_a? ::Time
+      raise ArgumentError, "Invalid from argument: from" unless from.is_a? ::Time
+      raise ArgumentError, "Invalid argument: from > to" if from > to
+      raise ArgumentError, "Invalid argument: gender" unless GENDERS.include?(gender.to_s)
+    end
+
+    GENDERS = k ["female", "male"]
+
+    def random_birth_time_between(from=::Time.local(1940, 1, 1), to=::Time.now)
+      ::Time.at(from + rand * (to.to_f - from.to_f))
+    end
+
+    def get_random_region_for(gender)
+      region_number = case gender
+      when "female" then get_random_region_even
+      when "male" then get_random_region_odd
+      end
+      three_character_string(region_number)
+    end
+
+    def get_random_region_even
+      rand(499) * 2
+    end
+
+    def get_random_region_odd
+      rand(499) * 2 + 1
+    end
+
+    def three_character_string(number)
+      "%03d" % number
+    end
+
+    # http://en.wikipedia.org/wiki/Luhn_algorithm
+    def luhn_check(number)
+      multiplications = []
+
+      number.split(//).each_with_index do |digit, i|
+        if i % 2 == 0
+          multiplications << digit.to_i * 2
+        else
+          multiplications << digit.to_i
+        end
+      end
+
+      sum = 0
+      multiplications.each do |num|
+        num.to_s.each_byte do |character|
+          sum += character.chr.to_i
+        end
+      end
+
+      if sum % 10 == 0
+        control_digit = 0
+      else
+        control_digit = (sum / 10 + 1) * 10 - sum
+      end
+
+      control_digit.to_s
+    end
+  end
+end

data/lib/ffakerer/string.rb

@@ -0,0 +1,92 @@
+# encoding: utf-8
+
+module Faker
+  module String
+    extend ModuleUtils
+    extend self
+
+    BACKSLASH = '\\'
+
+    LOWERS     = k(('a'..'z').to_a)
+    UPPERS     = k(('A'..'Z').to_a)
+    LETTERS    = k(LOWERS + UPPERS)
+    NUMBERS    = k(('0'..'9').to_a)
+    WORD_CHARS = k(LETTERS + NUMBERS + ['_'])
+    SPACES     = k([" ", "\t"])
+    ESCAPEABLE_CHARS = '\\', '/', '.', '(', ')', '[', ']', '{', '}'
+
+    def from_regexp(exp)
+      result = ''
+      @last_token = nil
+
+      # Drop surrounding /'s and split into characters
+      tokens = exp.inspect[1...-1].split(//)
+      until tokens.empty?
+        result << process_token(tokens)
+      end
+
+      result
+    end
+
+    private
+
+    def join_escapes(tokens)
+      result = []
+      while tokens.any?
+        token = tokens.shift
+        token << tokens.shift if token == BACKSLASH
+        result << token
+      end
+      result
+    end
+
+    def process_token(tokens)
+      return '' if tokens.empty?
+
+      token = tokens.shift
+
+      case token
+      when '?' then
+        # TODO: Let ? generate nothong
+        return '' # We already printed its target
+      when '+' then
+        tokens.unshift(token) if rand(2) == 1 # Leave the `+` on to run again
+        return process_token(@last_token) # Run the last one at least once
+      when '*' then
+        tokens.unshift(token) if rand(2) == 1 # Leave the `*` on to run again
+        return '' if rand(2) == 1 # Or maybe do nothing
+        return process_token(@last_token) # Else run the last one again
+      end
+
+      generate_token token, tokens
+    end
+
+    def generate_token(token, tokens)
+      case token
+      when /\w/ then
+        @last_token = [token]
+        token
+      when BACKSLASH then
+        token = tokens.shift
+        @last_token = ['\\', token]
+        special(token)
+      when '[' then
+        set = []
+        while (ch = tokens.shift) != ']'
+          set << ch
+        end
+        @last_token = ['['] + set + [']']
+        process_token([ArrayUtils.rand(join_escapes(set))])
+      end
+    end
+
+    def special(token)
+      case token
+      when 'w' then WORD_CHARS.rand
+      when 'd' then NUMBERS.rand
+      when 's' then SPACES.rand
+      when *ESCAPEABLE_CHARS then token
+      end
+    end
+  end
+end

data/lib/ffakerer/time.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+module Faker
+  module Time
+    extend ModuleUtils
+    extend self
+
+    def month
+      MONTHS.rand
+    end
+
+    def date(params={})
+      years_back = params[:year_range] || 5
+      latest_year  = params [:year_latest] || 0
+      year = (rand * (years_back)).ceil + (::Time.now.year - latest_year - years_back)
+      month = (rand * 12).ceil
+      day = (rand * 31).ceil
+      series = [date = ::Time.local(year, month, day)]
+      if params[:series]
+        params[:series].each do |some_time_after|
+          series << series.last + (rand * some_time_after).ceil
+        end
+        return series
+      end
+      date.strftime "%Y-%m-%d %T %z"
+    end
+
+    MONTHS = k %w(January February March April May June July August September October November December)
+  end
+end

data/lib/ffakerer/unit.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+require 'ostruct'
+
+module Faker
+  module Unit
+    extend ModuleUtils
+    extend self
+
+    def time_name
+      time.name
+    end
+
+    def time_abbr
+      time.abbreviation
+    end
+
+    def temperature_name
+      temperature.name
+    end
+
+    def temperature_abbr
+      temperature.abbreviation
+    end
+
+    private
+
+    def time
+      OpenStruct.new TIME_UNITS.rand
+    end
+
+    def temperature
+      OpenStruct.new TEMPERATURE_UNITS.rand
+    end
+
+    TIME_UNITS = k [
+      {:name => 'Years', :abbreviation => 'yr'},
+      {:name => 'Days', :abbreviation => 'd'},
+      {:name => 'Hours', :abbreviation => 'Minutes'},
+      {:name => 'Seconds', :abbreviation => 's'},
+      {:name => 'Milliseconds', :abbreviation => 'msec'}
+    ]
+
+    TEMPERATURE_UNITS = k [
+      {:name => 'Kelvin', :abbreviation => 'K'},
+      {:name => 'Celsius', :abbreviation => 'C'},
+      {:name => 'Fahrenheit', :abbreviation => 'F'}
+    ]
+  end
+end

data/lib/ffakerer/unit_english.rb

@@ -0,0 +1,114 @@
+# encoding: utf-8
+
+require 'ffakerer/unit'
+require 'ostruct'
+
+module Faker
+  module UnitEnglish
+    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 =>"inch", :abbreviation => "in"},
+      { :name =>"foot", :abbreviation => "ft"},
+      {  :name =>"yard", :abbreviation => "yd"},
+      { :name =>"furlong", :abbreviation => "fur"},
+      { :name =>"mile", :abbreviation => "m"}
+    ]
+
+    MASS_UNITS = k [
+      { :name => "grains", :abbreviation => "gr"},
+      { :name => "ounces", :abbreviation => "oz"},
+      { :name => "pounds", :abbreviation => "lb" },
+      { :name => "hundredweight", :abbreviation => "cwt"},
+      { :name => "ton", :abbreviation => "t" }
+    ]
+
+    LIQUID_UNITS = k [
+      { :name => "fluid ounce", :abbreviation => "fl oz"},
+      { :name => "gill", :abbreviation => "gi"},
+      { :name => "pint", :abbreviation => "pt"},
+      { :name => "quart", :abbreviation => "qt"}
+    ]
+
+    VOLUME_UNITS = k [
+      { :name =>"cubic inch", :abbreviation => "CI"},
+      { :name =>"cubic foot", :abbreviation => "CFT"},
+      { :name =>"cubic yard", :abbreviation => "CY"}
+    ]
+
+    AREA_UNITS = k [
+      { :name =>"square inch", :abbreviation => "sq. in"},
+      { :name =>"square foot", :abbreviation => "sq ft"},
+      { :name =>"square yard", :abbreviation => "sq yd"},
+      { :name =>"acre", :abbreviation => "ac"},
+      { :name =>"section", :abbreviation => "s"},
+      { :name =>"square mile", :abbreviation => "sq mi"},
+      { :name =>"township", :abbreviation => "Twp"}
+    ]
+  end
+end