faker 2.2.2

data/lib/faker/default/educator.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Faker
+  class Educator < Base
+    flexible :educator
+
+    class << self
+      def university
+        "#{parse('educator.name')} #{fetch('educator.tertiary.type')}"
+      end
+
+      def degree
+        "#{fetch('educator.tertiary.degree.type')} #{fetch('educator.tertiary.degree.subject')}"
+      end
+
+      alias course degree
+
+      def subject
+        fetch('educator.tertiary.degree.subject')
+      end
+
+      def course_name
+        "#{fetch('educator.tertiary.degree.subject')} #{numerify(fetch('educator.tertiary.degree.course_number'))}"
+      end
+
+      def secondary_school
+        "#{parse('educator.name')} #{fetch('educator.secondary')}"
+      end
+
+      def campus
+        "#{parse('educator.name')} Campus"
+      end
+    end
+  end
+end

data/lib/faker/default/electrical_components.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Faker
+  class ElectricalComponents < Base
+    flexible :electrical_components
+
+    class << self
+      def active
+        fetch('electrical_components.active')
+      end
+
+      def passive
+        fetch('electrical_components.passive')
+      end
+
+      def electromechanical
+        fetch('electrical_components.electromechanical')
+      end
+    end
+  end
+end

data/lib/faker/default/esport.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Faker
+  class Esport < Base
+    class << self
+      def player
+        fetch('esport.players')
+      end
+
+      def team
+        fetch('esport.teams')
+      end
+
+      def league
+        fetch('esport.leagues')
+      end
+
+      def event
+        fetch('esport.events')
+      end
+
+      def game
+        fetch('esport.games')
+      end
+    end
+  end
+end

data/lib/faker/default/file.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Faker
+  class File < Base
+    class << self
+      # rubocop:disable Metrics/ParameterLists
+      def dir(legacy_segment_count = NOT_GIVEN, legacy_root = NOT_GIVEN, legacy_directory_separator = NOT_GIVEN, segment_count: 3, root: nil, directory_separator: '/')
+        # rubocop:enable Metrics/ParameterLists
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :segment_count if legacy_segment_count != NOT_GIVEN
+          keywords << :root if legacy_root != NOT_GIVEN
+          keywords << :directory_separator if legacy_directory_separator != NOT_GIVEN
+        end
+
+        Array
+          .new(segment_count) { Faker::Internet.slug }
+          .unshift(root)
+          .compact
+          .join(directory_separator)
+          .squeeze(directory_separator)
+      end
+
+      def extension
+        fetch('file.extension')
+      end
+
+      def mime_type
+        fetch('file.mime_type')
+      end
+
+      # rubocop:disable Metrics/ParameterLists
+      def file_name(legacy_dir = NOT_GIVEN, legacy_name = NOT_GIVEN, legacy_ext = NOT_GIVEN, legacy_directory_separator = NOT_GIVEN, dir: nil, name: nil, ext: nil, directory_separator: '/')
+        # rubocop:enable Metrics/ParameterLists
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :dir if legacy_dir != NOT_GIVEN
+          keywords << :name if legacy_name != NOT_GIVEN
+          keywords << :ext if legacy_ext != NOT_GIVEN
+          keywords << :directory_separator if legacy_directory_separator != NOT_GIVEN
+        end
+
+        dir ||= dir(segment_count: 1)
+        name ||= Faker::Lorem.word.downcase
+        ext ||= extension
+
+        [dir, name].join(directory_separator) + ".#{ext}"
+      end
+    end
+  end
+end

data/lib/faker/default/fillmurray.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Faker
+  class Fillmurray < Base
+    class << self
+      # rubocop:disable Metrics/ParameterLists
+      def image(legacy_grayscale = NOT_GIVEN, legacy_width = NOT_GIVEN, legacy_height = NOT_GIVEN, grayscale: false, width: 200, height: 200)
+        # rubocop:enable Metrics/ParameterLists
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :grayscale if legacy_grayscale != NOT_GIVEN
+          keywords << :width if legacy_width != NOT_GIVEN
+          keywords << :height if legacy_height != NOT_GIVEN
+        end
+
+        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,44 @@
+# 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(legacy_country = NOT_GIVEN, country: 'BR')
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :country if legacy_country != NOT_GIVEN
+        end
+
+        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,97 @@
+# 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
+
+      # rubocop:disable Metrics/ParameterLists
+      def words(legacy_number = NOT_GIVEN, legacy_supplemental = NOT_GIVEN, legacy_spaces_allowed = NOT_GIVEN, number: 3, supplemental: false, spaces_allowed: false)
+        # rubocop:enable Metrics/ParameterLists
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :number if legacy_number != NOT_GIVEN
+          keywords << :supplemental if legacy_supplemental != NOT_GIVEN
+          keywords << :spaces_allowed if legacy_spaces_allowed != NOT_GIVEN
+        end
+
+        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
+
+      # rubocop:disable Metrics/ParameterLists
+      def sentence(legacy_word_count = NOT_GIVEN, legacy_supplemental = NOT_GIVEN, legacy_random_words_to_add = NOT_GIVEN, word_count: 4, supplemental: false, random_words_to_add: 6)
+        # rubocop:enable Metrics/ParameterLists
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :word_count if legacy_word_count != NOT_GIVEN
+          keywords << :supplemental if legacy_supplemental != NOT_GIVEN
+          keywords << :random_words_to_add if legacy_random_words_to_add != NOT_GIVEN
+        end
+
+        words(number: word_count + rand(random_words_to_add.to_i).to_i, supplemental: supplemental, spaces_allowed: true).join(' ').capitalize + '.'
+      end
+
+      def sentences(legacy_number = NOT_GIVEN, legacy_supplemental = NOT_GIVEN, number: 3, supplemental: false)
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :number if legacy_number != NOT_GIVEN
+          keywords << :supplemental if legacy_supplemental != NOT_GIVEN
+        end
+
+        [].tap do |sentences|
+          1.upto(resolve(number)) do
+            sentences << sentence(word_count: 3, supplemental: supplemental)
+          end
+        end
+      end
+
+      # rubocop:disable Metrics/ParameterLists
+      def paragraph(legacy_sentence_count = NOT_GIVEN, legacy_supplemental = NOT_GIVEN, legacy_random_sentences_to_add = NOT_GIVEN, sentence_count: 3, supplemental: false, random_sentences_to_add: 3)
+        # rubocop:enable Metrics/ParameterLists
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :sentence_count if legacy_sentence_count != NOT_GIVEN
+          keywords << :supplemental if legacy_supplemental != NOT_GIVEN
+          keywords << :random_sentences_to_add if legacy_random_sentences_to_add != NOT_GIVEN
+        end
+
+        sentences(number: resolve(sentence_count) + rand(random_sentences_to_add.to_i).to_i, supplemental: supplemental).join(' ')
+      end
+
+      def paragraphs(legacy_number = NOT_GIVEN, legacy_supplemental = NOT_GIVEN, number: 3, supplemental: false)
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :number if legacy_number != NOT_GIVEN
+          keywords << :supplemental if legacy_supplemental != NOT_GIVEN
+        end
+
+        [].tap do |paragraphs|
+          1.upto(resolve(number)) do
+            paragraphs << paragraph(sentence_count: 3, supplemental: supplemental)
+          end
+        end
+      end
+
+      def paragraph_by_chars(legacy_characters = NOT_GIVEN, legacy_supplemental = NOT_GIVEN, characters: 256, supplemental: false)
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :characters if legacy_characters != NOT_GIVEN
+          keywords << :supplemental if legacy_supplemental != NOT_GIVEN
+        end
+
+        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