faker 2.1.0

data/lib/faker/default/fillmurray.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Faker
+  class Fillmurray < Base
+    class << self
+      def image(grayscale: false, width: 200, height: 200)
+        raise ArgumentError, 'Width should be a number' unless width.to_s =~ /^\d+$/
+        raise ArgumentError, 'Height should be a number' unless height.to_s =~ /^\d+$/
+        raise ArgumentError, 'Grayscale should be a boolean' unless [true, false].include?(grayscale)
+
+        "https://www.fillmurray.com#{'/g' if grayscale == true}/#{width}/#{height}"
+      end
+    end
+  end
+end

data/lib/faker/default/finance.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Faker
+  class Finance < Base
+    CREDIT_CARD_TYPES = %i[visa mastercard discover american_express
+                           diners_club jcb switch solo dankort
+                           maestro forbrugsforeningen laser].freeze
+
+    class << self
+      def credit_card(*types)
+        types = CREDIT_CARD_TYPES if types.empty?
+        type = sample(types)
+        template = numerify(fetch("finance.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)
+      end
+
+      def vat_number(country: 'BR')
+        numerify(fetch("finance.vat_number.#{country}"))
+      rescue I18n::MissingTranslationData
+        raise ArgumentError, "Could not find vat number for #{country}"
+      end
+
+      def vat_number_keys
+        translate('faker.finance.vat_number').keys
+      end
+    end
+  end
+end

data/lib/faker/default/food.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Faker
+  class Food < Base
+    flexible :food
+
+    class << self
+      # Retrieves a typical dish from each country
+      def dish
+        fetch('food.dish')
+      end
+
+      # Retrieves a description about some dish
+      def description
+        fetch('food.descriptions')
+      end
+
+      # Retrieves an ingredient
+      def ingredient
+        fetch('food.ingredients')
+      end
+
+      # Retrieves a fruit
+      def fruits
+        fetch('food.fruits')
+      end
+
+      # Retrieves a vegetable
+      def vegetables
+        fetch('food.vegetables')
+      end
+
+      # Retrieves some random spice
+      def spice
+        fetch('food.spices')
+      end
+
+      # Retrieves cooking measures
+      def measurement
+        fetch('food.measurement_sizes') + ' ' + fetch('food.measurements')
+      end
+
+      # Retrieves metric mesurements
+      def metric_measurement
+        fetch('food.metric_measurements')
+      end
+    end
+  end
+end

data/lib/faker/default/funny_name.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Faker
+  class FunnyName < Base
+    flexible :funny_name
+
+    class << self
+      def name
+        fetch('funny_name.name')
+      end
+
+      def two_word_name
+        two_word_names = fetch_all('funny_name.name').select do |name|
+          name.count(' ') == 1
+        end
+
+        sample(two_word_names)
+      end
+
+      def three_word_name
+        three_word_names = fetch_all('funny_name.name').select do |name|
+          name.count(' ') == 2
+        end
+
+        sample(three_word_names)
+      end
+
+      def four_word_name
+        four_word_names = fetch_all('funny_name.name').select do |name|
+          name.count(' ') == 3
+        end
+
+        sample(four_word_names)
+      end
+
+      def name_with_initial
+        names_with_initials = fetch_all('funny_name.name').select do |name|
+          name.count('.').positive?
+        end
+
+        sample(names_with_initials)
+      end
+    end
+  end
+end

data/lib/faker/default/gender.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Faker
+  class Gender < Base
+    class << self
+      def type
+        fetch('gender.types')
+      end
+
+      def binary_type
+        fetch('gender.binary_types')
+      end
+    end
+  end
+end

data/lib/faker/default/greek_philosophers.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Faker
+  class GreekPhilosophers < Base
+    class << self
+      def name
+        fetch('greek_philosophers.names')
+      end
+
+      def quote
+        fetch('greek_philosophers.quotes')
+      end
+    end
+  end
+end

data/lib/faker/default/hacker.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+# Port of http://shinytoylabs.com/jargon/
+module Faker
+  class Hacker < Base
+    flexible :hacker
+
+    class << self
+      def say_something_smart
+        sample(phrases)
+      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}!".capitalize,
+         "I'll #{verb} the #{adjective} #{abbreviation} #{noun}, that should #{noun} the #{abbreviation} #{noun}!"]
+      end
+    end
+  end
+end

data/lib/faker/default/hipster.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Faker
+  class Hipster < Base
+    class << self
+      def word
+        random_word = sample(translate('faker.hipster.words'))
+        random_word =~ /\s/ ? word : random_word
+      end
+
+      def words(number: 3, supplemental: false, spaces_allowed: false)
+        resolved_num = resolve(number)
+        word_list = (
+          translate('faker.hipster.words') +
+          (supplemental ? translate('faker.lorem.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 sentence(word_count: 4, supplemental: false, random_words_to_add: 6)
+        words(number: word_count + rand(random_words_to_add.to_i).to_i, supplemental: supplemental, spaces_allowed: true).join(' ').capitalize + '.'
+      end
+
+      def sentences(number: 3, supplemental: false)
+        [].tap do |sentences|
+          1.upto(resolve(number)) do
+            sentences << sentence(word_count: 3, supplemental: supplemental)
+          end
+        end
+      end
+
+      def paragraph(sentence_count: 3, supplemental: false, random_sentences_to_add: 3)
+        sentences(number: resolve(sentence_count) + rand(random_sentences_to_add.to_i).to_i, supplemental: supplemental).join(' ')
+      end
+
+      def paragraphs(number: 3, supplemental: false)
+        [].tap do |paragraphs|
+          1.upto(resolve(number)) do
+            paragraphs << paragraph(sentence_count: 3, supplemental: supplemental)
+          end
+        end
+      end
+
+      def paragraph_by_chars(characters: 256, supplemental: false)
+        paragraph = paragraph(sentence_count: 3, supplemental: supplemental)
+
+        paragraph += ' ' + paragraph(sentence_count: 3, supplemental: supplemental) while paragraph.length < characters
+
+        paragraph[0...characters - 1] + '.'
+      end
+    end
+  end
+end

data/lib/faker/default/house.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Faker
+  class House < Base
+    class << self
+      def furniture
+        fetch('house.furniture')
+      end
+
+      def room
+        fetch('house.rooms')
+      end
+    end
+  end
+end

data/lib/faker/default/id_number.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Faker
+  class IDNumber < Base
+    CHECKS = 'TRWAGMYFPDXBNJZSQVHLCKE'
+    INVALID_SSN = [
+      /0{3}-\d{2}-\d{4}/,
+      /\d{3}-0{2}-\d{4}/,
+      /\d{3}-\d{2}-0{4}/,
+      /666-\d{2}-\d{4}/,
+      /9\d{2}-\d{2}-\d{4}/
+    ].freeze
+    ZA_RACE_DIGIT = '8'
+    ZA_CITIZENSHIP_DIGITS = %w[0 1].freeze
+
+    class << self
+      def valid
+        _translate('valid')
+      end
+
+      def invalid
+        _translate('invalid')
+      end
+
+      def ssn_valid
+        ssn = regexify(/[0-8]\d{2}-\d{2}-\d{4}/)
+        # We could still have all 0s in one segment or another
+        INVALID_SSN.any? { |regex| regex =~ ssn } ? ssn_valid : ssn
+      end
+
+      def spanish_citizen_number
+        num = Faker::Number.number(digits: 8)
+        mod = num.to_i % 23
+        check = CHECKS[mod]
+        "#{num}-#{check}"
+      end
+
+      def spanish_foreign_citizen_number
+        code = 'XYZ'
+        digits = Faker::Number.number(digits: 7)
+        prefix = code[rand(code.length)]
+        prefix_val = 'XYZ'.index(prefix).to_s
+        mod = "#{prefix_val}#{digits}".to_i % 23
+        check = CHECKS[mod]
+        "#{prefix}-#{digits}-#{check}"
+      end
+
+      def valid_south_african_id_number
+        id_number = [
+          Faker::Date.birthday.strftime('%y%m%d'),
+          Faker::Number.number(digits: 4),
+          ZA_CITIZENSHIP_DIGITS.sample(random: Faker::Config.random),
+          ZA_RACE_DIGIT
+        ].join
+
+        [id_number, south_african_id_checksum_digit(id_number)].join
+      end
+
+      alias south_african_id_number valid_south_african_id_number
+
+      def invalid_south_african_id_number
+        invalid_date_of_birth = [
+          Faker::Number.number(digits: 2),
+          Faker::Number.between(from: 13, to: 99),
+          Faker::Number.between(from: 32, to: 99)
+        ].map(&:to_s).join
+
+        id_number = [
+          invalid_date_of_birth,
+          Faker::Number.number(digits: 4),
+          ZA_CITIZENSHIP_DIGITS.sample(random: Faker::Config.random),
+          ZA_RACE_DIGIT
+        ].join
+
+        [id_number, south_african_id_checksum_digit(id_number)].join
+      end
+
+      def brazilian_citizen_number(formatted: false)
+        digits = Faker::Number.leading_zero_number(digits: 9) until digits&.match(/(\d)((?!\1)\d)+/)
+        first_digit = brazilian_citizen_number_checksum_digit(digits)
+        second_digit = brazilian_citizen_number_checksum_digit(digits + first_digit)
+        number = [digits, first_digit, second_digit].join
+        formatted ? format('%s.%s.%s-%s', *number.scan(/\d{2,3}/).flatten) : number
+      end
+
+      private
+
+      def south_african_id_checksum_digit(id_number)
+        value_parts = id_number.chars
+        even_digits = value_parts
+                      .select
+                      .with_index { |_, i| (i + 1).even? }
+        odd_digits_without_last_character = value_parts[0...-1]
+                                            .select
+                                            .with_index { |_, i| (i + 1).odd? }
+
+        sum_of_odd_digits = odd_digits_without_last_character.map(&:to_i).reduce(:+)
+        even_digits_times_two = (even_digits.join('').to_i * 2).to_s
+        sum_of_even_digits = even_digits_times_two.chars.map(&:to_i).reduce(:+)
+
+        total_sum = sum_of_odd_digits + sum_of_even_digits
+
+        ((10 - (total_sum % 10)) % 10).to_s
+      end
+
+      def brazilian_citizen_number_checksum_digit(digits)
+        digit_sum = digits.chars.each_with_index.inject(0) do |acc, (digit, i)|
+          acc + digit.to_i * (digits.size + 1 - i)
+        end * 10
+        remainder = digit_sum % 11
+        remainder == 10 ? '0' : remainder.to_s
+      end
+
+      def _translate(key)
+        parse("id_number.#{key}")
+      end
+    end
+  end
+end

data/lib/faker/default/industry_segments.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Faker
+  class IndustrySegments < Base
+    flexible :industry_segments
+
+    class << self
+      def industry
+        fetch('industry_segments.industry')
+      end
+
+      def super_sector
+        fetch('industry_segments.super_sector')
+      end
+
+      def sector
+        fetch('industry_segments.sector')
+      end
+
+      def sub_sector
+        fetch('industry_segments.sub_sector')
+      end
+    end
+  end
+end