faker 2.1.0

data/lib/faker/books/lovecraft.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Faker
+  class Books
+    class Lovecraft < Base
+      class << self
+        def location
+          fetch('lovecraft.location')
+        end
+
+        def fhtagn(number: 1)
+          Array.new(number) { fetch('lovecraft.fhtagn') }.join('. ')
+        end
+
+        def deity
+          fetch('lovecraft.deity')
+        end
+
+        def tome
+          fetch('lovecraft.tome')
+        end
+
+        def sentence(word_count: 4, random_words_to_add: 6)
+          words(number: word_count + rand(random_words_to_add.to_i).to_i, spaces_allowed: true).join(' ').capitalize + '.'
+        end
+
+        def word
+          random_word = sample(translate('faker.lovecraft.words'))
+          random_word =~ /\s/ ? word : random_word
+        end
+
+        def words(number: 3, spaces_allowed: false)
+          resolved_num = resolve(number)
+          word_list = translate('faker.lovecraft.words')
+          word_list *= ((resolved_num / word_list.length) + 1)
+
+          return shuffle(word_list)[0, resolved_num] if spaces_allowed
+
+          words = shuffle(word_list)[0, resolved_num]
+          words.each_with_index { |w, i| words[i] = word if w =~ /\s/ }
+        end
+
+        def sentences(number: 3)
+          [].tap do |sentences|
+            1.upto(resolve(number)) do
+              sentences << sentence(word_count: 3)
+            end
+          end
+        end
+
+        def paragraph(sentence_count: 3, random_sentences_to_add: 3)
+          sentences(number: resolve(sentence_count) + rand(random_sentences_to_add.to_i).to_i).join(' ')
+        end
+
+        def paragraphs(number: 3)
+          [].tap do |paragraphs|
+            1.upto(resolve(number)) do
+              paragraphs << paragraph(sentence_count: 3)
+            end
+          end
+        end
+
+        def paragraph_by_chars(characters: 256)
+          paragraph = paragraph(sentence_count: 3)
+
+          paragraph += ' ' + paragraph(sentence_count: 3) while paragraph.length < characters
+
+          paragraph[0...characters - 1] + '.'
+        end
+      end
+    end
+  end
+end

data/lib/faker/creature/animal.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Faker
+  class Creature
+    class Animal < Base
+      class << self
+        def name
+          fetch('creature.animal.name')
+        end
+      end
+    end
+  end
+end

data/lib/faker/creature/cat.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Faker
+  class Creature
+    class Cat < Base
+      flexible :cat
+
+      class << self
+        def name
+          fetch('creature.cat.name')
+        end
+
+        def breed
+          fetch('creature.cat.breed')
+        end
+
+        def registry
+          fetch('creature.cat.registry')
+        end
+      end
+    end
+  end
+end

data/lib/faker/creature/dog.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Faker
+  class Creature
+    class Dog < Base
+      flexible :dog
+
+      class << self
+        def name
+          fetch('creature.dog.name')
+        end
+
+        def breed
+          fetch('creature.dog.breed')
+        end
+
+        def sound
+          fetch('creature.dog.sound')
+        end
+
+        def meme_phrase
+          fetch('creature.dog.meme_phrase')
+        end
+
+        def age
+          fetch('creature.dog.age')
+        end
+
+        def gender
+          Faker::Gender.binary_type
+        end
+
+        def coat_length
+          fetch('creature.dog.coat_length')
+        end
+
+        def size
+          fetch('creature.dog.size')
+        end
+      end
+    end
+  end
+end

data/lib/faker/creature/horse.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Faker
+  class Creature
+    class Horse < Base
+      flexible :horse
+
+      class << self
+        def name
+          fetch('creature.horse.name')
+        end
+
+        def breed
+          fetch('creature.horse.breed')
+        end
+      end
+    end
+  end
+end

data/lib/faker/default/address.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Faker
+  class Address < Base
+    flexible :address
+
+    class << self
+      def city(options: {})
+        parse(options[:with_state] ? 'address.city_with_state' : '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
+        bothify(fetch('address.secondary_address'))
+      end
+
+      def building_number
+        bothify(fetch('address.building_number'))
+      end
+
+      def community
+        parse('address.community')
+      end
+
+      def zip_code(state_abbreviation: '')
+        if state_abbreviation.empty?
+          letterified_string = letterify(fetch('address.postcode'))
+          return numerify(letterified_string, leading_zero: true)
+        end
+
+        # 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 zip zip_code
+      alias 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_by_code(code: 'US')
+        fetch('address.country_by_code.' + code)
+      end
+
+      def country_name_to_code(name: 'united_states')
+        fetch('address.country_by_name.' + name)
+      end
+
+      def country_code
+        fetch('address.country_code')
+      end
+
+      def country_code_long
+        fetch('address.country_code_long')
+      end
+
+      def latitude
+        ((rand * 180) - 90).to_f
+      end
+
+      def longitude
+        ((rand * 360) - 180).to_f
+      end
+
+      def full_address
+        parse('address.full_address')
+      end
+    end
+  end
+end

data/lib/faker/default/alphanumeric.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Faker
+  class Alphanumeric < Base
+    class << self
+      ALPHABET = ('a'..'z').to_a
+      ALPHANUMS = ALPHABET + (0..9).to_a
+
+      def alpha(number: 32)
+        char_count = resolve(number)
+        return '' if char_count.to_i < 1
+
+        Array.new(char_count) { sample(ALPHABET) }.join
+      end
+
+      def alphanumeric(number: 32)
+        char_count = resolve(number)
+        return '' if char_count.to_i < 1
+
+        Array.new(char_count) { sample(ALPHANUMS) }.join
+      end
+    end
+  end
+end

data/lib/faker/default/ancient.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Faker
+  class Ancient < Base
+    class << self
+      def god
+        fetch('ancient.god')
+      end
+
+      def primordial
+        fetch('ancient.primordial')
+      end
+
+      def titan
+        fetch('ancient.titan')
+      end
+
+      def hero
+        fetch('ancient.hero')
+      end
+    end
+  end
+end

data/lib/faker/default/app.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Faker
+  class App < Base
+    class << self
+      def name
+        fetch('app.name')
+      end
+
+      def version
+        parse('app.version')
+      end
+
+      def author
+        parse('app.author')
+      end
+
+      def semantic_version(major: 0..9, minor: 0..9, patch: 1..9)
+        [major, minor, patch].map { |chunk| sample(Array(chunk)) }.join('.')
+      end
+    end
+  end
+end

data/lib/faker/default/appliance.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Faker
+  class Appliance < Base
+    class << self
+      def brand
+        fetch('appliance.brand')
+      end
+
+      def equipment
+        fetch('appliance.equipment')
+      end
+    end
+  end
+end

data/lib/faker/default/artist.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Faker
+  class Artist < Base
+    class << self
+      def name
+        fetch('artist.names')
+      end
+    end
+  end
+end

data/lib/faker/default/avatar.rb

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

data/lib/faker/default/bank.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Faker
+  class Bank < Base
+    flexible :bank
+
+    class << self
+      def account_number(digits: 10)
+        output = ''
+
+        output += rand.to_s[2..-1] while output.length < digits
+
+        output[0...digits]
+      end
+
+      def iban(country_code: 'GB')
+        # Each country has it's own format for bank accounts
+        # Many of them use letters in certain parts of the account
+        # Using regex patterns we can create virtually any type of bank account
+        begin
+          pattern = fetch("bank.iban_details.#{country_code.downcase}.bban_pattern")
+        rescue I18n::MissingTranslationData
+          raise ArgumentError, "Could not find iban details for #{country_code}"
+        end
+
+        # Use Faker::Base.regexify for creating a sample from bank account format regex
+        account = Base.regexify(/#{pattern}/)
+
+        # Add country code and checksum to the generated account to form valid IBAN
+        country_code.upcase + iban_checksum(country_code, account) + account
+      end
+
+      def name
+        fetch('bank.name')
+      end
+
+      def routing_number
+        valid_routing_number
+      end
+
+      def routing_number_with_format
+        compile_fraction(valid_routing_number)
+      end
+
+      def swift_bic
+        fetch('bank.swift_bic')
+      end
+
+      private
+
+      def checksum(num_string)
+        num_array = num_string.split('').map(&:to_i)
+        digit = (7 * (num_array[0] + num_array[3] + num_array[6]) + 3 * (num_array[1] + num_array[4] + num_array[7]) + 9 * (num_array[2] + num_array[5])) % 10
+        digit == num_array[8]
+      end
+
+      def compile_routing_number
+        digit_one_two = %w[00 01 02 03 04 05 06 07 08 09 10 11 12]
+        ((21..32).to_a + (61..72).to_a + [80]).each { |x| digit_one_two << x.to_s }
+        routing_num = digit_one_two.sample + rand_numstring + rand_numstring + rand_numstring + rand_numstring + rand_numstring + rand_numstring + rand_numstring
+        routing_num
+      end
+
+      # Calculates the mandatory checksum in 3rd and 4th characters in IBAN format
+      # source: https://en.wikipedia.org/wiki/International_Bank_Account_Number#Validating_the_IBAN
+      def iban_checksum(country_code, account)
+        # Converts letters to numbers according the iban rules, A=10..Z=35
+        account_to_number = "#{account}#{country_code}00".upcase.chars.map do |d|
+          d =~ /[A-Z]/ ? (d.ord - 55).to_s : d
+        end.join.to_i
+
+        # This is answer to (iban_to_num + checksum) % 97 == 1
+        checksum = (1 - account_to_number) % 97
+
+        # Use leftpad to make the size always to 2
+        checksum.to_s.rjust(2, '0')
+      end
+
+      def valid_routing_number
+        for _ in 0..50
+          micr = compile_routing_number
+
+          break if checksum(micr)
+        end
+        micr
+      end
+
+      def compile_fraction(routing_num)
+        prefix = (1..50).to_a.map(&:to_s).sample
+        numerator = routing_num.split('')[5..8].join.to_i.to_s
+        denominator = routing_num.split('')[0..4].join.to_i.to_s
+        prefix + '-' + numerator + '/' + denominator
+      end
+
+      def rand_numstring
+        (0..9).to_a.map(&:to_s).sample
+      end
+    end
+  end
+end