ffaker 2.2.0 → 2.3.0

data/lib/ffaker/skill.rb

@@ -6,15 +6,15 @@ module FFaker
     extend self
 
     def tech_skill
-      TECH_SKILLS.sample
+      fetch_sample(TECH_SKILLS)
     end
 
     def tech_skills(num = 3)
-      TECH_SKILLS.sample(num)
+      fetch_sample(TECH_SKILLS, count: num)
     end
 
     def specialty
-      "%s %s" % [SPECIALTY_START.sample, SPECIALTY_END.sample]
+      format('%s %s', fetch_sample(SPECIALTY_START), fetch_sample(SPECIALTY_END))
     end
 
     def specialties(num = 3)

data/lib/ffaker/sport.rb

@@ -4,7 +4,7 @@ module FFaker
     extend self
 
     def name
-      NAMES.sample
+      fetch_sample(NAMES)
     end
   end
 end

data/lib/ffaker/ssn_se.rb

@@ -3,7 +3,6 @@
 require 'date'
 
 module FFaker
-
   # The Social Security number is a 12-digit number in the format:
   # "YYYYDDMM-XXXX'
   #
@@ -24,12 +23,12 @@ module FFaker
     extend ModuleUtils
     extend self
 
-    GENDERS = ["female", "male"]
+    GENDERS = %w(female male).freeze
 
     def ssn(opts = {})
       from   = opts[:from]   || ::Time.local(1940, 1, 1)
       to     = opts[:to]     || ::Time.now
-      gender = (opts[:gender] || GENDERS.sample).to_s
+      gender = (opts[:gender] || fetch_sample(GENDERS)).to_s
 
       raise_error_on_bad_arguments(from, to, gender)
 
@@ -40,7 +39,7 @@ module FFaker
 
     def generate_ssn(from, to, gender)
       birth_date = random_birth_time_between(from, to)
-      birth_date_str = birth_date.strftime("%Y%m%d")      # "19800228"
+      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"
@@ -48,20 +47,20 @@ module FFaker
     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)
+      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)
+    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
+                      when 'female' then get_random_region_even
+                      when 'male' then get_random_region_odd
       end
       three_character_string(region_number)
     end
@@ -75,7 +74,7 @@ module FFaker
     end
 
     def three_character_string(number)
-      "%03d" % number
+      '%03d' % number
     end
 
     # http://en.wikipedia.org/wiki/Luhn_algorithm
@@ -83,10 +82,10 @@ module FFaker
       multiplications = []
 
       number.split(//).each_with_index do |digit, i|
-        if i % 2 == 0
-          multiplications << digit.to_i * 2
-        else
-          multiplications << digit.to_i
+        multiplications << if i.even?
+                             digit.to_i * 2
+                           else
+                             digit.to_i
         end
       end
 
@@ -97,10 +96,10 @@ module FFaker
         end
       end
 
-      if sum % 10 == 0
-        control_digit = 0
-      else
-        control_digit = (sum / 10 + 1) * 10 - sum
+      control_digit = if sum % 10 == 0
+                        0
+                      else
+                        (sum / 10 + 1) * 10 - sum
       end
 
       control_digit.to_s

data/lib/ffaker/string.rb

@@ -5,16 +5,16 @@ module FFaker
     extend ModuleUtils
     extend self
 
-    BACKSLASH = '\\'
-    DASH      = '-'
+    BACKSLASH = '\\'.freeze
+    DASH      = '-'.freeze
 
-    LOWERS     = [*'a'..'z']
-    UPPERS     = [*'A'..'Z']
+    LOWERS     = [*'a'..'z'].freeze
+    UPPERS     = [*'A'..'Z'].freeze
     LETTERS    = LOWERS + UPPERS
-    NUMBERS    = [*'0'..'9']
+    NUMBERS    = [*'0'..'9'].freeze
     WORD_CHARS = LETTERS + NUMBERS + ['_']
-    SPACES     = [' ', "\t"]
-    ESCAPEABLE_CHARS = '\\', '/', '.', '(', ')', '[', ']', '{', '}'
+    SPACES     = [' ', "\t"].freeze
+    ESCAPEABLE_CHARS = ['\\', '/', '.', '(', ')', '[', ']', '{', '}'].freeze
 
     def from_regexp(exp)
       result = ''
@@ -22,9 +22,7 @@ module FFaker
 
       # Drop surrounding /'s and split into characters
       tokens = exp.inspect[1...-1].split(//)
-      until tokens.empty?
-        result << process_token(tokens)
-      end
+      result << process_token(tokens) until tokens.empty?
 
       result
     end
@@ -47,24 +45,24 @@ module FFaker
     end
 
     def process_token(tokens)
-      return "" if tokens.empty?
+      return '' if tokens.empty?
 
       token = tokens.shift
 
       case token
-      when "?" then
+      when '?' then
         # TODO: Let ? generate nothing
-        "" # We already printed its target
-      when "+" then
+        '' # We already printed its target
+      when '+' then
         tokens.unshift(token) if rand(2) == 1 # Leave the `+` on to run again
         process_token(@last_token) # Run the last one at least once
-      when "*" then
+      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 '' if rand(2) == 1 # Or maybe do nothing
         process_token(@last_token) # Else run the last one again
-      when "{" then
-        number = ""
-        while (ch = tokens.shift) != "}"
+      when '{' then
+        number = ''
+        while (ch = tokens.shift) != '}'
           number << ch
         end
         number = number.to_i - 1
@@ -91,7 +89,7 @@ module FFaker
         end
         @last_token = ['['] + set + [']']
 
-        process_token([generate_range(set).sample])
+        process_token([fetch_sample(generate_range(set))])
       else
         token
       end
@@ -99,9 +97,9 @@ module FFaker
 
     def special(token)
       case token
-      when 'w' then WORD_CHARS.sample
-      when 'd' then NUMBERS.sample
-      when 's' then SPACES.sample
+      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
         ''

data/lib/ffaker/time.rb

@@ -5,26 +5,38 @@ module FFaker
     extend ModuleUtils
     extend self
 
-    MONTHS = %w(January February March April May June July August September October November December)
+    MONTHS = %w(January February March April May June July August September October November December).freeze
 
     def month
-      MONTHS.sample
+      fetch_sample(MONTHS)
     end
 
-    def date(params={})
+    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)
+      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)]
+      hours = params[:hours] || 0
+      minutes = params[:minutes] || 0
+      series = [date = ::Time.local(year, month, day, hours, minutes)]
       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"
+      date.strftime '%Y-%m-%d %T %z'
+    end
+
+    def datetime(params = {})
+      hours = params[:hours] || (rand * 12).ceil
+      minutes = params[:minutes] || (rand * 59).ceil
+      date(params.merge(hours: hours, minutes: minutes))
+    end
+
+    def between(from, to)
+      ::Time.at(from + rand * (to.to_f - from.to_f))
     end
   end
 end

data/lib/ffaker/tweet.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+
+module FFaker
+  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(1..10) - 6].max,
+        num_mentions: [0, rand(1..10) - 8].max,
+        reply: (rand(1..10) == 1),
+        body_length: rand(20..140)
+      }.merge(args)
+
+      my_reply = options[:reply] ? "#{mention} " : ''
+      my_mentions = options[:num_mentions] > 0 ? "#{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
+      "@#{FFaker::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}#{FFaker::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/ffaker/unit.rb

@@ -8,17 +8,17 @@ module FFaker
     extend self
 
     TIME_UNITS = [
-      {name: 'Years', abbreviation: 'yr'},
-      {name: 'Days', abbreviation: 'd'},
-      {name: 'Hours', abbreviation: 'Minutes'},
-      {name: 'Seconds', abbreviation: 's'},
-      {name: 'Milliseconds', abbreviation: 'msec'}
-    ]
+      { name: 'Years', abbreviation: 'yr' },
+      { name: 'Days', abbreviation: 'd' },
+      { name: 'Hours', abbreviation: 'Minutes' },
+      { name: 'Seconds', abbreviation: 's' },
+      { name: 'Milliseconds', abbreviation: 'msec' }
+    ].freeze
     TEMPERATURE_UNITS = [
-      {name: 'Kelvin', abbreviation: 'K'},
-      {name: 'Celsius', abbreviation: 'C'},
-      {name: 'Fahrenheit', abbreviation: 'F'}
-    ]
+      { name: 'Kelvin', abbreviation: 'K' },
+      { name: 'Celsius', abbreviation: 'C' },
+      { name: 'Fahrenheit', abbreviation: 'F' }
+    ].freeze
 
     def time_name
       time.name
@@ -39,11 +39,11 @@ module FFaker
     private
 
     def time
-      OpenStruct.new TIME_UNITS.sample
+      OpenStruct.new(fetch_sample(TIME_UNITS))
     end
 
     def temperature
-      OpenStruct.new TEMPERATURE_UNITS.sample
+      OpenStruct.new(fetch_sample(TEMPERATURE_UNITS))
     end
   end
 end

data/lib/ffaker/unit_english.rb

@@ -11,39 +11,39 @@ module FFaker
     extend self
 
     LENGTH_UNITS = [
-      { name: "inch", abbreviation: "in"},
-      { name: "foot", abbreviation: "ft"},
-      {  name: "yard", abbreviation: "yd"},
-      { name: "furlong", abbreviation: "fur"},
-      { name: "mile", abbreviation: "m"}
-    ]
+      { name: 'inch', abbreviation: 'in' },
+      { name: 'foot', abbreviation: 'ft' },
+      { name: 'yard', abbreviation: 'yd' },
+      { name: 'furlong', abbreviation: 'fur' },
+      { name: 'mile', abbreviation: 'm' }
+    ].freeze
     MASS_UNITS = [
-      { name: "grains", abbreviation: "gr"},
-      { name: "ounces", abbreviation: "oz"},
-      { name: "pounds", abbreviation: "lb" },
-      { name: "hundredweight", abbreviation: "cwt"},
-      { name: "ton", abbreviation: "t" }
-    ]
+      { 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"}
-    ]
+      { 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"}
-    ]
+      { 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"}
-    ]
+      { 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
@@ -88,24 +88,23 @@ module FFaker
     private
 
     def length
-      OpenStruct.new LENGTH_UNITS.sample
+      OpenStruct.new(fetch_sample(LENGTH_UNITS))
     end
 
     def mass
-      OpenStruct.new MASS_UNITS.sample
+      OpenStruct.new(fetch_sample(MASS_UNITS))
     end
 
     def liquid
-      OpenStruct.new LIQUID_UNITS.sample
+      OpenStruct.new(fetch_sample(LIQUID_UNITS))
     end
 
     def volume
-      OpenStruct.new VOLUME_UNITS.sample
+      OpenStruct.new(fetch_sample(VOLUME_UNITS))
     end
 
     def area
-      OpenStruct.new AREA_UNITS.sample
+      OpenStruct.new(fetch_sample(AREA_UNITS))
     end
-
   end
 end