ffakerTW 0.1.0

data/lib/ffakerTW/sport_ru.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module FFakerTW
+  # Inspirations:
+  # https://olympic.ru/team/sport/
+  # http://ru.sport-wiki.org/vidy-sporta/
+  module SportRU
+    extend ModuleUtils
+    extend self
+
+    ALL = SUMMER + WINTER
+
+    def name
+      fetch_sample(ALL)
+    end
+
+    def summer
+      fetch_sample(SUMMER)
+    end
+
+    def winter
+      fetch_sample(WINTER)
+    end
+  end
+end

data/lib/ffakerTW/sport_us.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module FFakerTW
+  module SportUS
+    extend ModuleUtils
+    extend self
+
+    def name
+      fetch_sample(NAMES)
+    end
+  end
+end

data/lib/ffakerTW/ssn.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module FFakerTW
+  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
+      first_group  = fetch_sample([*1..665, *667..899])
+      second_group = rand(1..99)
+      third_group  = rand(1..9999)
+
+      group_numbers = [first_group, second_group, third_group]
+      format('%.3d-%.2d-%.4d', *group_numbers)
+    end
+  end
+end

data/lib/ffakerTW/ssn_mx.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module FFakerTW
+  module SSNMX
+    extend ModuleUtils
+    extend self
+
+    # The Social Security number is a eleven-digit number in the format
+    # "AABBCCDDEE-F".
+    def ssn
+      FFakerTW.numerify('##########-#')
+    end
+
+    # The Social Security number is a eleven-digit number in the format
+    # "AABBCCDDEEF".
+    def ssn_undashed
+      FFakerTW.numerify('###########')
+    end
+
+    # http://es.wikipedia.org/wiki/Instituto_Mexicano_del_Seguro_Social
+    # The Social Security number from IMSS
+    # (Instituto Mexicano del Seguro Social)
+    # is a eleven-digit number in the format
+    # "AABBCCDDEE-F".
+    def imss
+      FFakerTW.numerify('##########-#')
+    end
+
+    # http://es.wikipedia.org/wiki/Instituto_Mexicano_del_Seguro_Social
+    # The Social Security number from IMSS
+    # (Instituto Mexicano del Seguro Social)
+    # is a eleven-digit number in the format
+    # "AABBCCDDEEF".
+    def imss_undashed
+      FFakerTW.numerify('###########')
+    end
+
+    # http://es.wikipedia.org/wiki/Instituto_de_Seguridad_y_Servicios_Sociales_de_los_Trabajadores_del_Estado
+    # The Social Security number from ISSSTE
+    # (Instituto de Seguridad y Servicios Sociales de los Trabajadores del Estado)
+    # is a eleven-digit number in the format
+    # "AABBCCDDEE-F".
+    def issste
+      FFakerTW.numerify('##########-#')
+    end
+
+    # http://es.wikipedia.org/wiki/Instituto_de_Seguridad_y_Servicios_Sociales_de_los_Trabajadores_del_Estado
+    # The Social Security number from ISSSTE
+    # (Instituto de Seguridad y Servicios Sociales de los Trabajadores del Estado)
+    # is a eleven-digit number in the format
+    # "AABBCCDDEEF".
+    def issste_undashed
+      FFakerTW.numerify('###########')
+    end
+  end
+end

data/lib/ffakerTW/ssn_se.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'date'
+
+module FFakerTW
+  # 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
+
+    GENDERS = %w[female male].freeze
+
+    def ssn(opts = {})
+      from   = opts[:from] || ::Time.local(1940, 1, 1)
+      to     = opts[:to] || ::Time.now
+      gender = (opts[:gender] || fetch_sample(GENDERS)).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 = 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
+
+    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 random_region_for(gender)
+      region_number = case gender
+                      when 'female' then random_region_even
+                      when 'male' then random_region_odd
+                      end
+      three_character_string(region_number)
+    end
+
+    def random_region_even
+      rand(0..498) * 2
+    end
+
+    def random_region_odd
+      rand(0..498) * 2 + 1
+    end
+
+    def three_character_string(number)
+      format('%03d', number)
+    end
+  end
+end

data/lib/ffakerTW/string.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module FFakerTW
+  module String
+    extend ModuleUtils
+    extend self
+
+    BACKSLASH = '\\'
+    DASH      = '-'
+
+    LOWERS     = Array('a'..'z').freeze
+    UPPERS     = Array('A'..'Z').freeze
+    LETTERS    = LOWERS + UPPERS
+    NUMBERS    = Array('0'..'9').freeze
+    WORD_CHARS = LETTERS + NUMBERS + ['_']
+    SPACES     = [' ', "\t"].freeze
+    ESCAPEABLE_CHARS = ['\\', '/', '.', '(', ')', '[', ']', '{', '}'].freeze
+
+    def from_regexp(exp)
+      result = +''
+      @last_token = nil
+
+      # Drop surrounding /'s and split into characters
+      tokens = exp.inspect[1...-1].split(//)
+      result << process_token(tokens) until tokens.empty?
+
+      result
+    end
+
+    private
+
+    def generate_range(tokens)
+      result = []
+      while tokens.any?
+        token = tokens.shift
+        if token == DASH && tokens.first && result.last
+          result += Array(result.pop..tokens.shift)
+        elsif token == BACKSLASH
+          result << special(tokens.shift)
+        else
+          result << token
+        end
+      end
+      result
+    end
+
+    def process_token(tokens)
+      return '' if tokens.empty?
+
+      token = tokens.shift
+
+      case token
+      when '?'
+        # TODO: Let ? generate nothing
+        '' # We already printed its target
+      when '+'
+        tokens.unshift(token) if rand(0..1) == 1 # Leave the `+` on to run again
+        process_token(@last_token) # Run the last one at least once
+      when '*'
+        tokens.unshift(token) if rand(0..1) == 1 # Leave the `*` on to run again
+        return '' if rand(0..1) == 1 # Or maybe do nothing
+
+        process_token(@last_token) # Else run the last one again
+      when '{'
+        number = +''
+        while (ch = tokens.shift) != '}'
+          number << ch
+        end
+        number = number.to_i - 1
+        t = @last_token.dup
+        Array.new(number) { process_token(t.dup) }.join
+      else
+        generate_token token, tokens
+      end
+    end
+
+    def generate_token(token, tokens)
+      case token
+      when /\w/
+        @last_token = [token]
+        token
+      when BACKSLASH
+        token = tokens.shift
+        @last_token = ['\\', token]
+        special(token)
+      when '['
+        set = []
+        while (ch = tokens.shift) != ']'
+          set << ch
+        end
+        @last_token = ['['] + set + [']']
+
+        process_token([fetch_sample(generate_range(set))])
+      else
+        token
+      end
+    end
+
+    def special(token)
+      case token
+      when 'w' then fetch_sample(WORD_CHARS)
+      when 'd' then fetch_sample(NUMBERS)
+      when 's' then fetch_sample(SPACES)
+      when *ESCAPEABLE_CHARS then token
+      else
+        ''
+      end
+    end
+  end
+end

data/lib/ffakerTW/time.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'date'
+
+module FFakerTW
+  module Time
+    extend ModuleUtils
+    extend self
+
+    MONTHS = %w[
+      January February March April May June July August September October November December
+    ].freeze
+    DAYS_OF_WEEK = %w[Monday Tuesday Wednesday Thursday Friday Saturday Sunday].freeze
+
+    def month
+      fetch_sample(MONTHS)
+    end
+
+    def day_of_week(options = {})
+      fetch_sample(DAYS_OF_WEEK)[0..(options[:long] ? 10 : 2)]
+    end
+
+    def datetime(params = {})
+      years_back = params[:year_range] || 5
+      latest_year = params[:year_latest] || 0
+      year = (rand * years_back).ceil + (::DateTime.now.year - latest_year - years_back)
+      month = rand(1..12)
+      day = rand(1..Date.new(year, month, -1).day)
+      hours = params[:hours] || rand(0..23)
+      minutes = params[:minutes] || rand(0..59)
+      series = [date = ::DateTime.new(year, month, day, hours, minutes)]
+      return date unless params[:series]
+
+      params[:series].each do |some_time_after|
+        series << series.last + (rand * some_time_after).ceil
+      end
+      series
+    end
+
+    def date(params = {})
+      datetime(params).to_date
+    end
+
+    def between(from, to)
+      from_value = convert_to_time(from)
+      to_value = convert_to_time(to)
+      ::Time.at(from_value + rand * (to_value.to_f - from_value.to_f))
+    end
+
+    private
+
+    def convert_to_time(value)
+      case value.class.name
+      when 'String'
+        DateTime.parse(value).to_time
+      when 'Date', 'DateTime', 'ActiveSupport::TimeWithZone'
+        value.to_time
+      when 'Time'
+        value
+      else
+        raise "FFakerTW cannot convert #{value.class} '#{value}' to Time"
+      end
+    end
+  end
+end

data/lib/ffakerTW/tweet.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module FFakerTW
+  module Tweet
+    extend ModuleUtils
+    extend self
+
+    # Options
+    # num_hashtags:   How many hashtags (default: (skewed (40%) 1-4))
+    # num_mentions:   How many mentions (default: (skewed (20% 1-2))
+    # reply:          Add reply? (default: (random 10%)
+    # body_length:    Target length (rand(20..140)) (will be <= target)
+    def tweet(args = {})
+      options = {
+        num_hashtags: [0, rand(-5..4)].max,
+        num_mentions: [0, rand(-7..2)].max,
+        reply: (rand(1..10) == 1),
+        body_length: rand(20..140)
+      }.merge(args)
+
+      my_reply = options[:reply] ? "#{mention} " : ''
+      my_mentions = (options[:num_mentions]).positive? ? "#{mentions(options[:num_mentions])} " : ''
+      my_tags = tags(options[:num_hashtags])
+
+      remaining = [
+        options[:body_length],
+        140 - (my_reply.size + my_mentions.size + my_tags.size)
+      ].min
+
+      "#{my_reply}#{body(remaining)}#{my_mentions}#{my_tags}"
+    end
+
+    def mention
+      "@#{FFakerTW::Internet.user_name}"
+    end
+
+    def mentions(num = 2)
+      mention_names = []
+      num.times { mention_names << mention }
+      mention_names.join(' ')
+    end
+
+    def body(required_length = 140)
+      required_length = [required_length, 20].max
+      body = ''
+      prefix = ''
+      until body.size > required_length
+        body += "#{prefix}#{FFakerTW::Lorem.sentence}"
+        prefix = ' '
+      end
+      body[required_length - 1] = '#'
+      body.gsub(/\s\S*\#.*$/, '.')
+    end
+
+    def tags(num_tags = 2)
+      fetch_sample(HASHTAG, count: num_tags).join(' ')
+    end
+  end
+end

data/lib/ffakerTW/unit.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module FFakerTW
+  module Unit
+    extend ModuleUtils
+    extend self
+
+    TIME_UNITS = [
+      { name: 'Years', abbreviation: 'yr' },
+      { name: 'Days', abbreviation: 'd' },
+      { name: 'Hours', abbreviation: 'h' },
+      { name: 'Minutes', abbreviation: 'm' },
+      { name: 'Seconds', abbreviation: 's' },
+      { name: 'Milliseconds', abbreviation: 'ms' }
+    ].freeze
+    TEMPERATURE_UNITS = [
+      { name: 'Kelvin', abbreviation: 'K' },
+      { name: 'Celsius', abbreviation: 'C' },
+      { name: 'Fahrenheit', abbreviation: 'F' }
+    ].freeze
+
+    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
+      fetch_sample(TIME_UNITS)
+    end
+
+    def temperature
+      fetch_sample(TEMPERATURE_UNITS)
+    end
+  end
+end

data/lib/ffakerTW/unit_english.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module FFakerTW
+  module UnitEnglish
+    include FFakerTW::Unit
+
+    extend ModuleUtils
+    extend self
+
+    LENGTH_UNITS = [
+      { name: 'inch', abbreviation: 'in' },
+      { name: 'foot', abbreviation: 'ft' },
+      { name: 'yard', abbreviation: 'yd' },
+      { name: 'furlong', abbreviation: 'fur' },
+      { name: 'mile', abbreviation: 'mi' }
+    ].freeze
+    MASS_UNITS = [
+      { name: 'grains', abbreviation: 'gr' },
+      { name: 'ounces', abbreviation: 'oz' },
+      { name: 'pounds', abbreviation: 'lb' },
+      { name: 'hundredweight', abbreviation: 'cwt' },
+      { name: 'ton', abbreviation: 't' }
+    ].freeze
+    LIQUID_UNITS = [
+      { name: 'fluid ounce', abbreviation: 'fl oz' },
+      { name: 'gill', abbreviation: 'gi' },
+      { name: 'pint', abbreviation: 'pt' },
+      { name: 'quart', abbreviation: 'qt' }
+    ].freeze
+    VOLUME_UNITS = [
+      { name: 'cubic inch', abbreviation: 'CI' },
+      { name: 'cubic foot', abbreviation: 'CFT' },
+      { name: 'cubic yard', abbreviation: 'CY' }
+    ].freeze
+    AREA_UNITS = [
+      { 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' }
+    ].freeze
+
+    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
+      fetch_sample(LENGTH_UNITS)
+    end
+
+    def mass
+      fetch_sample(MASS_UNITS)
+    end
+
+    def liquid
+      fetch_sample(LIQUID_UNITS)
+    end
+
+    def volume
+      fetch_sample(VOLUME_UNITS)
+    end
+
+    def area
+      fetch_sample(AREA_UNITS)
+    end
+  end
+end

data/lib/ffakerTW/unit_metric.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module FFakerTW
+  module UnitMetric
+    include FFakerTW::Unit
+
+    extend ModuleUtils
+    extend self
+
+    LENGTH_UNITS = [
+      { name: 'millimeters', abbreviation: 'mm' },
+      { name: 'centimeters', abbreviation: 'cm' },
+      { name: 'meters', abbreviation: 'm' },
+      { name: 'kilometers', abbreviation: 'km' }
+    ].freeze
+    MASS_UNITS = [
+      { name: 'gram', abbreviation: 'g' },
+      { name: 'kilogram', abbreviation: 'kg' },
+      { name: 'metric ton', abbreviation: 'mt' }
+    ].freeze
+    LIQUID_UNITS = [
+      { name: 'milliliters', abbreviation: 'ml' },
+      { name: 'liters', abbreviation: 'L' }
+    ].freeze
+    VOLUME_UNITS = [
+      { name: ' cubic centimeters', abbreviation: 'cm^3' },
+      { name: 'cubic meters', abbreviation: 'm^3' }
+    ].freeze
+    AREA_UNITS = [
+      { name: 'centimeters squared', abbreviation: 'cm^2' },
+      { name: 'meters squared', abbreviation: 'm^2' },
+      { name: 'hectares', abbreviation: 'ha' },
+      { name: 'kilometers', abbreviation: 'km' }
+    ].freeze
+
+    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
+      fetch_sample(LENGTH_UNITS)
+    end
+
+    def mass
+      fetch_sample(MASS_UNITS)
+    end
+
+    def liquid
+      fetch_sample(LIQUID_UNITS)
+    end
+
+    def volume
+      fetch_sample(VOLUME_UNITS)
+    end
+
+    def area
+      fetch_sample(AREA_UNITS)
+    end
+  end
+end