factory-helper 1.5.0

data/lib/factory-helper/commerce.rb

@@ -0,0 +1,51 @@
+module Faker
+  class Commerce < Base
+
+    class << self
+      def color
+        fetch('commerce.color')
+      end
+
+      def department(max = 3, fixed_amount = false)
+        num = max if fixed_amount
+        num ||= 1 + rand(max)
+
+        categories = categories(num)
+
+        if num > 1
+          merge_categories(categories)
+        else
+          categories[0]
+        end
+      end
+
+      def product_name
+        fetch('commerce.product_name.adjective') + ' ' + fetch('commerce.product_name.material') + ' ' + fetch('commerce.product_name.product')
+      end
+
+      def price
+        random = Random.new
+        (random.rand(0..100.0) * 100).floor/100.0
+      end    
+
+      private
+
+      def categories(num)
+        categories = []
+        while categories.length < num do
+          category = fetch('commerce.department')
+          categories << category unless categories.include?(category)
+        end
+
+        categories
+      end
+
+      def merge_categories(categories)
+        separator = fetch('separator')
+        comma_separated = categories.slice!(0...-1).join(', ')
+
+        [comma_separated, categories[0]].join(separator)
+      end
+    end
+  end
+end

data/lib/factory-helper/company.rb

@@ -0,0 +1,40 @@
+module Faker
+  class Company < Base
+    flexible :company
+
+    class << self
+      def name
+        parse('company.name')
+      end
+
+      def suffix
+        fetch('company.suffix')
+      end
+
+      # Generate a buzzword-laden catch phrase.
+      def catch_phrase
+        translate('faker.company.buzzwords').collect {|list| list.sample }.join(' ')
+      end
+
+      # When a straight answer won't do, BS to the rescue!
+      def bs
+        translate('faker.company.bs').collect {|list| list.sample }.join(' ')
+      end
+
+      def ein
+        ('%09d' % rand(10 ** 9)).gsub(/(\d\d)(\d\d\d\d\d\d\d)/, '\\1-\\2')
+      end
+
+      def duns_number
+        ('%09d' % rand(10 ** 9)).gsub(/(\d\d)(\d\d\d)(\d\d\d\d)/, '\\1-\\2-\\3')
+      end
+
+      # Get a random company logo url in PNG format.
+      def logo
+        rand_num = Random.rand(13) + 1
+        "http://pigment.github.io/fake-logos/logos/medium/color/#{rand_num}.png"
+      end
+    end
+
+  end
+end

data/lib/factory-helper/date.rb

@@ -0,0 +1,42 @@
+module Faker
+  class Date < Base
+    class << self
+      def between(from, to)
+        from = get_date_object(from)
+        to   = get_date_object(to)
+
+        Faker::Base::rand_in_range(from, to)
+      end
+
+      def forward(days = 365)
+        from = ::Date.today + 1
+        to   = ::Date.today + days
+
+        between(from, to).to_date
+      end
+
+      def backward(days = 365)
+        from = ::Date.today - days
+        to   = ::Date.today - 1
+
+        between(from, to).to_date
+      end
+
+      def birthday(min_age = 18, max_age = 65)
+        t = ::Date.today
+        from =  ::Date.new(t.year - min_age, t.month, t.day)
+        to   =  ::Date.new(t.year - max_age, t.month, t.day)
+
+        between(from, to).to_date
+      end
+
+      private
+
+      def get_date_object(date)
+        date = ::Date.parse(date) if date.is_a?(String)
+        date = date.to_date if date.respond_to?(:to_date)
+        date
+      end
+    end
+  end
+end

data/lib/factory-helper/finance.rb

@@ -0,0 +1,26 @@
+module Faker
+  class Finance < Base
+    CREDIT_CARD_TYPES = [ :visa, :mastercard,  :discover, :american_express, :diners_club, :jcb, :switch, :solo, :dankort, :maestro, :forbrugsforeningen, :laser ]
+
+    class << self
+      def credit_card(*types)
+        types = CREDIT_CARD_TYPES if types.empty?
+        type = types.sample
+        template = numerify(fetch("credit_card.#{type}"))
+
+        # calculate the luhn checksum digit
+        multiplier = 1
+        luhn_sum = template.gsub(/[^0-9]/, '').split('').reverse.map(&:to_i).inject(0) do |sum, digit|
+          multiplier = (multiplier == 2 ? 1 : 2)
+          sum + (digit * multiplier).to_s.split('').map(&:to_i).inject(0) { |digit_sum, cur| digit_sum + cur }
+        end
+        # the sum plus whatever the last digit is must be a multiple of 10. So, the
+        # last digit must be 10 - the last digit of the sum.
+        luhn_digit = (10 - (luhn_sum % 10)) % 10
+
+        template.gsub! 'L', luhn_digit.to_s
+        template
+      end
+    end
+  end
+end

data/lib/factory-helper/hacker.rb

@@ -0,0 +1,31 @@
+#Port of http://shinytoylabs.com/jargon/
+module Faker
+  class Hacker < Base
+    flexible :hacker
+    
+    class << self
+      def say_something_smart
+        phrases.sample
+      end
+      
+      def abbreviation;  fetch('hacker.abbreviation'); end
+      def adjective;     fetch('hacker.adjective'); end
+      def noun;          fetch('hacker.noun'); end
+      def verb;          fetch('hacker.verb'); end
+      def ingverb;       fetch('hacker.ingverb'); end
+                    
+      def phrases
+         [ "If we #{verb} the #{noun}, we can get to the #{abbreviation} #{noun} through the #{adjective} #{abbreviation} #{noun}!",
+           "We need to #{verb} the #{adjective} #{abbreviation} #{noun}!",
+           "Try to #{verb} the #{abbreviation} #{noun}, maybe it will #{verb} the #{adjective} #{noun}!",
+           "You can't #{verb} the #{noun} without #{ingverb} the #{adjective} #{abbreviation} #{noun}!",
+           "Use the #{adjective} #{abbreviation} #{noun}, then you can #{verb} the #{adjective} #{noun}!",
+           "The #{abbreviation} #{noun} is down, #{verb} the #{adjective} #{noun} so we can #{verb} the #{abbreviation} #{noun}!",
+           "#{ingverb} the #{noun} won't do anything, we need to #{verb} the #{adjective} #{abbreviation} #{noun}!",
+           "I'll #{verb} the #{adjective} #{abbreviation} #{noun}, that should #{noun} the #{abbreviation} #{noun}!"               
+           ]
+      end
+    end
+
+  end
+end

data/lib/factory-helper/internet.rb

@@ -0,0 +1,116 @@
+# encoding: utf-8
+module Faker
+  class Internet < Base
+    class << self
+      def email(name = nil)
+        [ user_name(name), domain_name ].join('@')
+      end
+
+      def free_email(name = nil)
+        [ user_name(name), fetch('internet.free_email') ].join('@')
+      end
+
+      def safe_email(name = nil)
+        [user_name(name), 'example.'+ %w[org com net].shuffle.first].join('@')
+      end
+
+      def user_name(specifier = nil, separators = %w(. _))
+        if specifier.kind_of? String
+          return specifier.scan(/\w+/).shuffle.join(separators.sample).downcase
+        elsif specifier.kind_of? Integer
+          tries = 0 # Don't try forever in case we get something like 1_000_000.
+          begin
+            result = user_name nil, separators
+            tries += 1
+          end while result.length < specifier and tries < 7
+          until result.length >= specifier
+            result = result * 2
+          end
+          return result
+        elsif specifier.kind_of? Range
+          tries = 0
+          begin
+            result = user_name specifier.min, separators
+            tries += 1
+          end while not specifier.include? result.length and tries < 7
+          return result[0...specifier.max]
+        end
+
+        fix_umlauts([
+          Proc.new { Name.first_name.gsub(/\W/, '').downcase },
+          Proc.new {
+            [ Name.first_name, Name.last_name ].map {|n|
+              n.gsub(/\W/, '')
+            }.join(separators.sample).downcase }
+        ].sample.call)
+      end
+
+      def password(min_length = 8, max_length = 16)
+        temp = Lorem.characters(min_length)
+        diff_length = max_length - min_length
+        if diff_length > 0
+          diff_rand = rand(diff_length + 1)
+          temp += Lorem.characters(diff_rand)
+        end
+        temp = temp[0..min_length] if min_length > 0
+        return temp
+      end
+
+      def domain_name
+        [ fix_umlauts(domain_word), domain_suffix ].join('.')
+      end
+
+      def fix_umlauts(string)
+        string.gsub(/[äöüß]/i) do |match|
+            case match.downcase
+                when "ä" 'ae'
+                when "ö" 'oe'
+                when "ü" 'ue'
+                when "ß" 'ss'
+            end
+        end
+      end
+
+      def domain_word
+        Company.name.split(' ').first.gsub(/\W/, '').downcase
+      end
+
+      def domain_suffix
+        fetch('internet.domain_suffix')
+      end
+
+      def mac_address(prefix='')
+        prefix_digits = prefix.split(':').map{ |d| d.to_i(16) }
+        address_digits = (6 - prefix_digits.size).times.map{ rand(256) }
+        (prefix_digits + address_digits).map{ |d| '%02x' % d }.join(':')
+      end
+
+      def ip_v4_address
+        ary = (2..254).to_a
+        [ary.sample,
+        ary.sample,
+        ary.sample,
+        ary.sample].join('.')
+      end
+
+      def ip_v6_address
+        @@ip_v6_space ||= (0..65535).to_a
+        container = (1..8).map{ |_| @@ip_v6_space.sample }
+        container.map{ |n| n.to_s(16) }.join(':')
+      end
+
+      def url(host = domain_name, path = "/#{user_name}")
+        "http://#{host}#{path}"
+      end
+
+      def slug(words = nil, glue = nil)
+        glue ||= %w[- _ .].sample
+        (words || Faker::Lorem::words(2).join(' ')).gsub(' ', glue).downcase
+      end
+
+      def device_token
+        rand(16 ** 64).to_s(16).rjust(64, '0').chars.to_a.shuffle.join
+      end
+    end
+  end
+end

data/lib/factory-helper/lorem.rb

@@ -0,0 +1,66 @@
+module Faker
+  # Based on Perl's Text::Lorem
+  class Lorem < Base
+    class << self
+      def word
+        translate('faker.lorem.words').sample
+      end
+
+      def words(num = 3, supplemental = false)
+        resolved_num = resolve(num)
+        word_list = (
+          translate('faker.lorem.words') +
+          (supplemental ? translate('faker.lorem.supplemental') : [])
+        )
+        word_list = word_list * ((resolved_num / word_list.length) + 1)
+        word_list.shuffle[0, resolved_num]
+      end
+
+      def character
+        characters(1)
+      end
+
+      def characters(char_count = 255)
+        return '' if char_count.respond_to?(:to_i) && char_count.to_i < 1
+        char_count = resolve(char_count)
+        rand(36**char_count).to_s(36).rjust(char_count, '0').chars.to_a.shuffle.join
+      end
+
+      def sentence(word_count = 4, supplemental = false, random_words_to_add = 6)
+        words(word_count + rand(random_words_to_add.to_i).to_i, supplemental).join(' ').capitalize + '.'
+      end
+
+      def sentences(sentence_count = 3, supplemental = false)
+        [].tap do |sentences|
+          1.upto(resolve(sentence_count)) do
+            sentences << sentence(3, supplemental)
+          end
+        end
+      end
+
+      def paragraph(sentence_count = 3, supplemental = false, random_sentences_to_add = 3)
+        sentences(resolve(sentence_count) + rand(random_sentences_to_add.to_i).to_i, supplemental).join(' ')
+      end
+
+      def paragraphs(paragraph_count = 3, supplemental = false)
+        [].tap do |paragraphs|
+          1.upto(resolve(paragraph_count)) do
+            paragraphs << paragraph(3, supplemental)
+          end
+        end
+      end
+
+    private
+
+      # If an array or range is passed, a random value will be selected.
+      # All other values are simply returned.
+      def resolve(value)
+        case value
+        when Array then value[rand(value.size)]
+        when Range then rand((value.last+1) - value.first) + value.first
+        else value
+        end
+      end
+    end
+  end
+end

data/lib/factory-helper/name.rb

@@ -0,0 +1,22 @@
+module Faker
+  class Name < Base
+    flexible :name
+
+    class << self
+
+      def name
+        parse('name.name')
+      end
+
+      def first_name; fetch('name.first_name'); end
+      def last_name;  fetch('name.last_name'); end
+      def prefix;     fetch('name.prefix'); end
+      def suffix;     fetch('name.suffix'); end
+
+      # Generate a buzzword-laden job title
+      # Wordlist from http://www.bullshitjob.com/title/
+      def title; fetch('name.title.descriptor') + ' ' + fetch('name.title.level') + ' ' + fetch('name.title.job'); end
+
+    end
+  end
+end

data/lib/factory-helper/number.rb

@@ -0,0 +1,57 @@
+module Faker
+  class Number < Base
+    class << self
+      def number(digits)
+        (1..digits).collect {digit}.join
+      end
+
+      def decimal(l_digits, r_digits = 2)
+        l_d = self.number(l_digits)
+        r_d = self.number(r_digits)
+        "#{l_d}.#{r_d}"
+      end
+
+      def digit
+        (rand() * 9).round.to_s
+      end
+
+      def hexadecimal(digits)
+        hex = ""
+        digits.times { hex += rand(15).to_s(16) }
+        hex
+      end
+
+      def between(from = 1.00, to = 5000.00)
+        Faker::Base::rand_in_range(from, to)
+      end
+
+      def positive(from = 1.00, to = 5000.00)
+        random_number = between(from, to)
+        greater_than_zero(random_number)
+      end
+
+      def negative(from = -5000.00, to = -1.00)
+        random_number = between(from, to)
+        less_than_zero(random_number)
+      end
+
+      private
+
+      def greater_than_zero(number)
+        should_be(number, :>)
+      end
+
+      def less_than_zero(number)
+        should_be(number, :<)
+      end
+
+      def should_be(number, method_to_compare)
+        if number.send(method_to_compare, 0)
+          number
+        else
+          number * -1
+        end
+      end
+    end
+  end
+end