factory-helper 1.5.0

data/lib/extensions/array.rb

@@ -0,0 +1,22 @@
+class Array
+  unless self.method_defined? :sample
+    def sample(n = nil)
+      #based on code from https://github.com/marcandre/backports
+      size = self.length
+      return self[Kernel.rand(size)] if n.nil?
+
+      n = n.to_int
+      raise ArgumentError, "negative array size" if n < 0
+
+      n = size if n > size
+
+      result = Array.new(self)
+      n.times do |i|
+        r = i + Kernel.rand(size - i)
+        result[i], result[r] = result[r], result[i]
+      end
+      result[n..size] = []
+      result
+    end
+  end
+end

data/lib/extensions/symbol.rb

@@ -0,0 +1,9 @@
+# For Ruby 1.8
+unless :symbol.respond_to?(:downcase)
+  Symbol.class_eval do
+    def downcase
+      to_s.downcase.intern
+    end
+  end
+end
+

data/lib/factory-helper.rb

@@ -0,0 +1,182 @@
+# -*- coding: utf-8 -*-
+mydir = File.expand_path(File.dirname(__FILE__))
+
+begin
+  require 'psych'
+rescue LoadError
+end
+
+require 'i18n'
+require 'set' # Fixes a bug in i18n 0.6.11
+
+if I18n.respond_to?(:enforce_available_locales=)
+  I18n.enforce_available_locales = true
+end
+I18n.load_path += Dir[File.join(mydir, 'locales', '*.yml')]
+
+
+module Faker
+  class Config
+    @locale = nil
+
+    class << self
+      attr_writer :locale
+      def locale
+        @locale || I18n.locale
+      end
+    end
+  end
+
+  class Base
+    Numbers = Array(0..9)
+    ULetters = Array('A'..'Z')
+    Letters = ULetters + Array('a'..'z')
+
+    class << self
+      ## make sure numerify results doesn’t start with a zero
+      def numerify(number_string)
+        number_string.sub(/#/) { (rand(9)+1).to_s }.gsub(/#/) { rand(10).to_s }
+      end
+
+      def letterify(letter_string)
+        letter_string.gsub(/\?/) { ULetters.sample }
+      end
+
+      def bothify(string)
+        letterify(numerify(string))
+      end
+
+      # Given a regular expression, attempt to generate a string
+      # that would match it.  This is a rather simple implementation,
+      # so don't be shocked if it blows up on you in a spectacular fashion.
+      #
+      # It does not handle ., *, unbounded ranges such as {1,},
+      # extensions such as (?=), character classes, some abbreviations
+      # for character classes, and nested parentheses.
+      #
+      # I told you it was simple. :) It's also probably dog-slow,
+      # so you shouldn't use it.
+      #
+      # It will take a regex like this:
+      #
+      # /^[A-PR-UWYZ0-9][A-HK-Y0-9][AEHMNPRTVXY0-9]?[ABEHMNPRVWXY0-9]? {1,2}[0-9][ABD-HJLN-UW-Z]{2}$/
+      #
+      # and generate a string like this:
+      #
+      # "U3V  3TP"
+      #
+      def regexify(re)
+        re = re.source if re.respond_to?(:source) # Handle either a Regexp or a String that looks like a Regexp
+        re.
+          gsub(/^\/?\^?/, '').gsub(/\$?\/?$/, '').                                                                      # Ditch the anchors
+          gsub(/\{(\d+)\}/, '{\1,\1}').gsub(/\?/, '{0,1}').                                                             # All {2} become {2,2} and ? become {0,1}
+          gsub(/(\[[^\]]+\])\{(\d+),(\d+)\}/) {|match| $1 * Array(Range.new($2.to_i, $3.to_i)).sample }.                # [12]{1,2} becomes [12] or [12][12]
+          gsub(/(\([^\)]+\))\{(\d+),(\d+)\}/) {|match| $1 * Array(Range.new($2.to_i, $3.to_i)).sample }.                # (12|34){1,2} becomes (12|34) or (12|34)(12|34)
+          gsub(/(\\?.)\{(\d+),(\d+)\}/) {|match| $1 * Array(Range.new($2.to_i, $3.to_i)).sample }.                      # A{1,2} becomes A or AA or \d{3} becomes \d\d\d
+          gsub(/\((.*?)\)/) {|match| match.gsub(/[\(\)]/, '').split('|').sample }.                                      # (this|that) becomes 'this' or 'that'
+          gsub(/\[([^\]]+)\]/) {|match| match.gsub(/(\w\-\w)/) {|range| Array(Range.new(*range.split('-'))).sample } }. # All A-Z inside of [] become C (or X, or whatever)
+          gsub(/\[([^\]]+)\]/) {|match| $1.split('').sample }.                                                          # All [ABC] become B (or A or C)
+          gsub('\d') {|match| Numbers.sample }.
+          gsub('\w') {|match| Letters.sample }
+      end
+
+      # Helper for the common approach of grabbing a translation
+      # with an array of values and selecting one of them.
+      def fetch(key)
+        fetched = translate("faker.#{key}")
+        fetched = fetched.sample if fetched.respond_to?(:sample)
+        if fetched.match(/^\//) and fetched.match(/\/$/) # A regex
+          regexify(fetched)
+        else
+          fetched
+        end
+      end
+
+      # Load formatted strings from the locale, "parsing" them
+      # into method calls that can be used to generate a
+      # formatted translation: e.g., "#{first_name} #{last_name}".
+      def parse(key)
+        fetch(key).scan(/(\(?)#\{([A-Za-z]+\.)?([^\}]+)\}([^#]+)?/).map {|prefix, kls, meth, etc|
+          # If the token had a class Prefix (e.g., Name.first_name)
+          # grab the constant, otherwise use self
+          cls = kls ? Faker.const_get(kls.chop) : self
+
+          # If an optional leading parentheses is not present, prefix.should == "", otherwise prefix.should == "("
+          # In either case the information will be retained for reconstruction of the string.
+          text = prefix
+
+          # If the class has the method, call it, otherwise
+          # fetch the transation (i.e., faker.name.first_name)
+          text += cls.respond_to?(meth) ? cls.send(meth) : fetch("#{(kls || self).to_s.split('::').last.downcase}.#{meth.downcase}")
+
+          # And tack on spaces, commas, etc. left over in the string
+          text += etc.to_s
+        }.join
+      end
+
+      # Call I18n.translate with our configured locale if no
+      # locale is specified
+      def translate(*args)
+        opts = args.last.is_a?(Hash) ? args.pop : {}
+        opts[:locale] ||= Faker::Config.locale
+        opts[:raise] = true
+        I18n.translate(*(args.push(opts)))
+      rescue I18n::MissingTranslationData
+        # Super-simple fallback -- fallback to en if the
+        # translation was missing.  If the translation isn't
+        # in en either, then it will raise again.
+        I18n.translate(*(args.push(opts.merge(:locale => :en))))
+      end
+
+      def flexible(key)
+        @flexible_key = key
+      end
+
+      # You can add whatever you want to the locale file, and it will get caught here.
+      # E.g., in your locale file, create a
+      #   name:
+      #     girls_name: ["Alice", "Cheryl", "Tatiana"]
+      # Then you can call Faker::Name.girls_name and it will act like #first_name
+      def method_missing(m, *args, &block)
+        super unless @flexible_key
+
+        # Use the alternate form of translate to get a nil rather than a "missing translation" string
+        if translation = translate(:faker)[@flexible_key][m]
+          translation.respond_to?(:sample) ? translation.sample : translation
+        else
+          super
+        end
+      end
+
+      # Generates a random value between the interval
+      def rand_in_range(from, to)
+        from, to = to, from if to < from
+        Random.new.rand(from..to)
+      end
+    end
+  end
+end
+
+require_relative 'factory-helper/address'
+require_relative 'factory-helper/code'
+require_relative 'factory-helper/company'
+require_relative 'factory-helper/finance'
+require_relative 'factory-helper/internet'
+require_relative 'factory-helper/lorem'
+require_relative 'factory-helper/name'
+require_relative 'factory-helper/team'
+require_relative 'factory-helper/phone_number'
+require_relative 'factory-helper/business'
+require_relative 'factory-helper/commerce'
+require_relative 'factory-helper/version'
+require_relative 'factory-helper/number'
+require_relative 'factory-helper/bitcoin'
+require_relative 'factory-helper/avatar'
+require_relative 'factory-helper/date'
+require_relative 'factory-helper/time'
+require_relative 'factory-helper/number'
+require_relative 'factory-helper/hacker'
+require_relative 'factory-helper/app'
+
+require_relative 'extensions/array'
+require_relative 'extensions/symbol'

data/lib/factory-helper/address.rb

@@ -0,0 +1,59 @@
+module Faker
+  class Address < Base
+    flexible :address
+
+    class << self
+      def city
+        parse('address.city')
+      end
+
+      def street_name
+        parse('address.street_name')
+      end
+
+      def street_address(include_secondary = false)
+        numerify(parse('address.street_address') + (include_secondary ? ' ' + secondary_address : ''))
+      end
+
+      def secondary_address
+        numerify(fetch('address.secondary_address'))
+      end
+
+      def building_number
+        bothify(fetch('address.building_number'))
+      end
+
+      def zip_code(state_abbreviation = '')
+        return bothify(fetch('address.postcode')) if state_abbreviation === ''
+
+        # provide a zip code that is valid for the state provided
+        # see http://www.fincen.gov/forms/files/us_state_territory_zip_codes.pdf
+        bothify(fetch('address.postcode_by_state.' + state_abbreviation))
+      end
+
+      def time_zone
+        fetch('address.time_zone')
+      end
+
+      alias_method :zip, :zip_code
+      alias_method :postcode, :zip_code
+
+      def street_suffix; fetch('address.street_suffix'); end
+      def city_suffix;   fetch('address.city_suffix');   end
+      def city_prefix;   fetch('address.city_prefix');   end
+      def state_abbr;    fetch('address.state_abbr');    end
+      def state;         fetch('address.state');         end
+      def country;       fetch('address.country');       end
+      def country_code;  fetch('address.country_code');  end
+
+      def latitude
+        ((rand * 180) - 90).to_s
+      end
+
+      def longitude
+        ((rand * 360) - 180).to_s
+      end
+
+    end
+  end
+end

data/lib/factory-helper/app.rb

@@ -0,0 +1,22 @@
+module Faker
+  class App < Base
+    class << self
+
+      def name
+        fetch('app.name')
+      end
+
+      def version
+        if parse('app.version') == ""
+          numerify(fetch('app.version'))
+        else
+          parse('app.version')
+        end
+      end
+
+      def author
+        parse('app.author')
+      end
+    end
+  end
+end

data/lib/factory-helper/avatar.rb

@@ -0,0 +1,14 @@
+module Faker
+  class Avatar < Base
+    class << self
+      SUPPORTED_FORMATS = %w(png jpg bmp)
+
+      def image(slug = nil, size = '300x300', format = 'png')
+        raise ArgumentError, "Size should be specified in format 300x300" unless size.match(/^[0-9]+x[0-9]+$/)
+        raise ArgumentError, "Supported formats are #{SUPPORTED_FORMATS.join(', ')}" unless SUPPORTED_FORMATS.include?(format)
+        slug ||= Faker::Lorem.words.join
+        "http://robohash.org/#{slug}.#{format}?size=#{size}"
+      end
+    end
+  end
+end

data/lib/factory-helper/bitcoin.rb

@@ -0,0 +1,49 @@
+require 'digest'
+require 'securerandom'
+
+module Faker
+  class Bitcoin < Base
+    class << self
+
+      PROTOCOL_VERSIONS = {
+        main: 0,
+        testnet: 111
+      }
+
+      def address
+        address_for(:main)
+      end
+
+      def testnet_address
+        address_for(:testnet)
+      end
+
+      protected
+
+      def base58(str)
+        alphabet = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
+        base = alphabet.size
+
+        lv = 0
+        str.split('').reverse.each_with_index { |v,i| lv += v.unpack('C')[0] * 256**i }
+
+        ret = ''
+        while lv > 0 do
+          lv, mod = lv.divmod(base)
+          ret << alphabet[mod]
+        end
+
+        npad = str.match(/^#{0.chr}*/)[0].to_s.size
+        '1'*npad + ret.reverse
+      end
+
+      def address_for(network)
+        version = PROTOCOL_VERSIONS.fetch(network)
+        hash = SecureRandom.hex(20)
+        packed = version.chr + [hash].pack("H*")
+        checksum = Digest::SHA2.digest(Digest::SHA2.digest(packed))[0..3]
+        base58(packed + checksum)
+      end
+    end
+  end
+end

data/lib/factory-helper/business.rb

@@ -0,0 +1,22 @@
+require 'date'
+
+module Faker
+  class Business < Base
+    flexible :business
+
+    class << self
+      def credit_card_number
+        fetch('business.credit_card_numbers')
+      end
+
+      def credit_card_expiry_date
+        ::Date.parse(fetch('business.credit_card_expiry_dates'))
+      end
+
+      def credit_card_type
+        fetch('business.credit_card_types')
+      end
+    end
+
+  end
+end

data/lib/factory-helper/code.rb

@@ -0,0 +1,63 @@
+module Faker
+  class Code < Base
+    class << self
+      # By default generates 10 sign isbn code in format 123456789-X
+      # You can pass 13 to generate new 13 sign code
+      def isbn(base = 10)
+        base == 13 ? generate_base13_isbn : generate_base10_isbn
+      end
+
+      # By default generates 13 sign ean code in format 1234567890123
+      # You can pass 8 to generate ean8 code
+      def ean(base = 13)
+        base == 8 ? generate_base8_ean : generate_base13_ean
+      end
+
+      def rut
+        value = Number.number(8)
+        vd = rut_verificator_digit(value)
+        value << "-#{vd}"
+      end
+
+    private
+
+      def generate_base10_isbn
+        values = regexify(/\d{9}/)
+        remainder = sum(values) { |value, index| (index + 1) * value.to_i } % 11
+        values << "-#{remainder == 10 ? 'X' : remainder}"
+      end
+
+      def generate_base13_isbn
+        values = regexify(/\d{12}/)
+        remainder = sum(values) { |value, index| index.even? ? value.to_i : value.to_i * 3 } % 10
+        values << "-#{((10 - remainder) % 10)}"
+      end
+
+      def sum(values, &block)
+        values.split(//).each_with_index.inject(0) do |sum, (value, index)|
+          sum + block.call(value, index)
+        end
+      end
+
+      def generate_base8_ean
+        values = regexify(/\d{7}/)
+        check_digit = 10 - values.split(//).each_with_index.inject(0){ |s, (v, i)| s + v.to_i * EAN_CHECK_DIGIT8[i] } % 10
+        values << (check_digit == 10 ? 0 : check_digit).to_s
+      end
+
+      def generate_base13_ean
+        values = regexify(/\d{12}/)
+        check_digit = 10 - values.split(//).each_with_index.inject(0){ |s, (v, i)| s + v.to_i * EAN_CHECK_DIGIT13[i] } % 10
+        values << (check_digit == 10 ? 0 : check_digit).to_s
+      end
+
+      EAN_CHECK_DIGIT8 = [3, 1, 3, 1, 3, 1, 3]
+      EAN_CHECK_DIGIT13 = [1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3]
+
+      def rut_verificator_digit(rut)
+        total = rut.to_s.rjust(8, '0').split(//).zip(%w(3 2 7 6 5 4 3 2)).collect{|a, b| a.to_i * b.to_i}.inject(:+)
+        (11 - total % 11).to_s.gsub(/10/, 'k').gsub(/11/, '0')
+      end
+    end
+  end
+end