faker 2.0.0 → 3.8.0

data/lib/faker/tv_shows/venture_bros.rb

@@ -6,18 +6,56 @@ module Faker
       flexible :venture_bros
 
       class << self
+        ##
+        # Produces a character from The Venture Bros.
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::TvShows::VentureBros.character #=> "Scaramantula"
+        #
+        # @faker.version 1.8.3
         def character
           fetch('venture_bros.character')
         end
 
+        ##
+        # Produces an organization from The Venture Bros.
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::TvShows::VentureBros.organization
+        #     #=> "Guild of Calamitous Intent"
+        #
+        # @faker.version 1.8.3
         def organization
           fetch('venture_bros.organization')
         end
 
+        ##
+        # Produces a vehicle from The Venture Bros.
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::TvShows::VentureBros.vehicle #=> "Monarchmobile"
+        #
+        # @faker.version 1.8.3
         def vehicle
           fetch('venture_bros.vehicle')
         end
 
+        ##
+        # Produces a quote from The Venture Bros.
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::TvShows::VentureBros.quote
+        #     #=> "Revenge, like gazpacho soup, is best served cold, precise, and merciless."
+        #
+        # @faker.version 1.8.3
         def quote
           fetch('venture_bros.quote')
         end

data/lib/faker/tv_shows.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Faker
+  class TvShows
+    if Faker::Config.lazy_loading?
+      Faker.lazy_load(self)
+    end
+  end
+end

data/lib/faker/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-module Faker #:nodoc:
-  VERSION = '2.0.0'
+module Faker # :nodoc:
+  VERSION = '3.8.0'
 end

data/lib/faker.rb

@@ -2,37 +2,53 @@
 
 mydir = __dir__
 
-begin
-  require 'psych'
-end
-
+require 'psych'
 require 'i18n'
-require 'set' # Fixes a bug in i18n 0.6.11
 
-Dir.glob(File.join(File.dirname(__FILE__), 'helpers', '*.rb')).sort.each { |file| require file }
+autoload(:OpenSSL, 'openssl')
+
+Dir.glob(File.join(mydir, 'helpers', '*.rb')).each { |file| require file }
 
 I18n.load_path += Dir[File.join(mydir, 'locales', '**/*.yml')]
-I18n.reload! if I18n.backend.initialized?
 
 module Faker
-  class Config
-    @locale = nil
-    @random = nil
+  module Config
+    @default_locale = nil
 
     class << self
-      attr_writer :locale
-      attr_writer :random
+      attr_writer :default_locale
+
+      def locale=(new_locale)
+        Thread.current[:faker_config_locale] = new_locale
+      end
 
       def locale
-        @locale || I18n.locale
+        # Because I18n.locale defaults to :en, if we don't have :en in our available_locales, errors will happen
+        Thread.current[:faker_config_locale] || @default_locale || (I18n.available_locales.include?(I18n.locale) ? I18n.locale : I18n.available_locales.first)
       end
 
       def own_locale
-        @locale
+        Thread.current[:faker_config_locale]
+      end
+
+      def random=(new_random)
+        Thread.current[:faker_config_random] = new_random
       end
 
       def random
-        @random || Random::DEFAULT
+        Thread.current[:faker_config_random] || Random
+      end
+
+      def lazy_loading?
+        if ENV.key?('FAKER_LAZY_LOAD') && !ENV['FAKER_LAZY_LOAD'].nil?
+          %w[true TRUE 1].include?(ENV.fetch('FAKER_LAZY_LOAD', nil))
+        else
+          Thread.current[:faker_lazy_loading] == true
+        end
+      end
+
+      def lazy_loading=(value)
+        Thread.current[:faker_lazy_loading] = value
       end
     end
   end
@@ -40,24 +56,33 @@ module Faker
   class Base
     Numbers = Array(0..9)
     ULetters = Array('A'..'Z')
-    Letters = ULetters + Array('a'..'z')
+    LLetters = Array('a'..'z')
+    Letters = ULetters + LLetters
 
     class << self
+      attr_reader :flexible_key
+
+      NOT_GIVEN = Object.new
+
       ## by default numerify results do not start with a zero
       def numerify(number_string, leading_zero: false)
-        return number_string.gsub(/#/) { rand(10).to_s } if leading_zero
+        return number_string.gsub('#') { rand(10).to_s } if leading_zero
 
-        number_string.sub(/#/) { rand(1..9).to_s }.gsub(/#/) { rand(10).to_s }
+        number_string.sub('#') { rand(1..9).to_s }.gsub('#') { rand(10).to_s }
       end
 
       def letterify(letter_string)
-        letter_string.gsub(/\?/) { sample(ULetters) }
+        letter_string.gsub('?') { sample(ULetters) }
       end
 
       def bothify(string)
         letterify(numerify(string))
       end
 
+      def generate(as_type, &)
+        PositionalGenerator.new(as_type, &).generate
+      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.
@@ -80,14 +105,14 @@ module Faker
       def regexify(reg)
         reg = reg.source if reg.respond_to?(:source) # Handle either a Regexp or a String that looks like a Regexp
         reg
-          .gsub(%r{^\/?\^?}, '').gsub(%r{\$?\/?$}, '') # Ditch the anchors
-          .gsub(/\{(\d+)\}/, '{\1,\1}').gsub(/\?/, '{0,1}') # All {2} become {2,2} and ? become {0,1}
-          .gsub(/(\[[^\]]+\])\{(\d+),(\d+)\}/) { |_match| Regexp.last_match(1) * sample(Array(Range.new(Regexp.last_match(2).to_i, Regexp.last_match(3).to_i))) }                # [12]{1,2} becomes [12] or [12][12]
-          .gsub(/(\([^\)]+\))\{(\d+),(\d+)\}/) { |_match| Regexp.last_match(1) * sample(Array(Range.new(Regexp.last_match(2).to_i, Regexp.last_match(3).to_i))) }                # (12|34){1,2} becomes (12|34) or (12|34)(12|34)
-          .gsub(/(\\?.)\{(\d+),(\d+)\}/) { |_match| Regexp.last_match(1) * sample(Array(Range.new(Regexp.last_match(2).to_i, Regexp.last_match(3).to_i))) }                      # A{1,2} becomes A or AA or \d{3} becomes \d\d\d
-          .gsub(/\((.*?)\)/) { |match| sample(match.gsub(/[\(\)]/, '').split('|')) } # (this|that) becomes 'this' or 'that'
-          .gsub(/\[([^\]]+)\]/) { |match| match.gsub(/(\w\-\w)/) { |range| sample(Array(Range.new(*range.split('-')))) } } # All A-Z inside of [] become C (or X, or whatever)
-          .gsub(/\[([^\]]+)\]/) { |_match| sample(Regexp.last_match(1).split('')) } # All [ABC] become B (or A or C)
+          .gsub(%r{^/?\^?}, '').gsub(%r{\$?/?$}, '') # Ditch the anchors
+          .gsub(/\{(\d+)\}/, '{\1,\1}').gsub('?', '{0,1}') # All {2} become {2,2} and ? become {0,1}
+          .gsub(/(\[[^\]]++\])\{(\d+),(\d+)\}/) { |_match| Regexp.last_match(1) * sample(Array(Range.new(Regexp.last_match(2).to_i, Regexp.last_match(3).to_i))) }                # [12]{1,2} becomes [12] or [12][12]
+          .gsub(/(\([^)]++\))\{(\d+),(\d+)\}/) { |_match| Regexp.last_match(1) * sample(Array(Range.new(Regexp.last_match(2).to_i, Regexp.last_match(3).to_i))) }                 # (12|34){1,2} becomes (12|34) or (12|34)(12|34)
+          .gsub(/(\\?.)\{(\d+),(\d+)\}/) { |_match| Regexp.last_match(1) * sample(Array(Range.new(Regexp.last_match(2).to_i, Regexp.last_match(3).to_i))) }                       # A{1,2} becomes A or AA or \d{3} becomes \d\d\d
+          .gsub(/\((.*?)\)/) { |match| sample(match.gsub(/[()]/, '').split('|')) }                                                                                                # (this|that) becomes 'this' or 'that'
+          .gsub(/\[([^\]]++)\]/) { |match| match.gsub(/(\w-\w)/) { |range| sample(Array(Range.new(*range.split('-')))) } }                                                        # All A-Z inside of [] become C (or X, or whatever)
+          .gsub(/\[([^\]]++)\]/) { |_match| sample(Regexp.last_match(1).chars) }                                                                                                  # All [ABC] become B (or A or C)
           .gsub('\d') { |_match| sample(Numbers) }
           .gsub('\w') { |_match| sample(Letters) }
       end
@@ -96,7 +121,7 @@ module Faker
       # with an array of values and selecting one of them.
       def fetch(key)
         fetched = sample(translate("faker.#{key}"))
-        if fetched&.match(%r{^\/}) && fetched&.match(%r{\/$}) # A regex
+        if fetched&.match(%r{^/}) && fetched.match(%r{/$}) # A regex
           regexify(fetched)
         else
           fetched
@@ -108,7 +133,7 @@ module Faker
       def fetch_all(key)
         fetched = translate("faker.#{key}")
         fetched = fetched.last if fetched.size <= 1
-        if !fetched.respond_to?(:sample) && fetched.match(%r{^\/}) && fetched.match(%r{\/$}) # A regex
+        if !fetched.respond_to?(:sample) && fetched.match(%r{^/}) && fetched.match(%r{/$}) # A regex
           regexify(fetched)
         else
           fetched
@@ -120,7 +145,8 @@ module Faker
       # formatted translation: e.g., "#{first_name} #{last_name}".
       def parse(key)
         fetched = fetch(key)
-        parts = fetched.scan(/(\(?)#\{([A-Za-z]+\.)?([^\}]+)\}([^#]+)?/).map do |prefix, kls, meth, etc|
+
+        parts = fetched.scan(/(\(?)#\{([A-Za-z]+\.)?([^}]+)\}([^#]++)?/).map do |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
@@ -129,7 +155,7 @@ module Faker
           # 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
+          # If the class has the method, call it, otherwise fetch the translation
           # (e.g., faker.phone_number.area_code)
           text += if cls.respond_to?(meth)
                     cls.send(meth)
@@ -148,30 +174,28 @@ module Faker
 
       # Call I18n.translate with our configured locale if no
       # locale is specified
-      def translate(*args)
-        opts = args.last.is_a?(Hash) ? args.pop : {}
+      def translate(*args, **opts)
         opts[:locale] ||= Faker::Config.locale
         opts[:raise] = true
-        I18n.translate(*args.push(opts))
+        I18n.translate(*args, **opts)
       rescue I18n::MissingTranslationData
-        opts = args.last.is_a?(Hash) ? args.pop : {}
         opts[:locale] = :en
 
         # Super-simple fallback -- fallback to en if the
         # translation was missing.  If the translation isn't
         # in en either, then it will raise again.
         disable_enforce_available_locales do
-          I18n.translate(*args.push(opts))
+          I18n.translate(*args, **opts)
         end
       end
 
       # Executes block with given locale set.
-      def with_locale(tmp_locale = nil)
+      def with_locale(tmp_locale = nil, &block)
         current_locale = Faker::Config.own_locale
         Faker::Config.locale = tmp_locale
 
         disable_enforce_available_locales do
-          I18n.with_locale(tmp_locale) { yield }
+          I18n.with_locale(tmp_locale, &block)
         end
       ensure
         Faker::Config.locale = current_locale
@@ -186,10 +210,10 @@ module Faker
       #   name:
       #     girls_name: ["Alice", "Cheryl", "Tatiana"]
       # Then you can call Faker::Name.girls_name and it will act like #first_name
-      def method_missing(mth, *args, &block)
-        super unless @flexible_key
+      def method_missing(mth, *args, &)
+        super unless flexible_key
 
-        if (translation = translate("faker.#{@flexible_key}.#{mth}"))
+        if (translation = translate("faker.#{flexible_key}.#{mth}"))
           sample(translation)
         else
           super
@@ -216,18 +240,34 @@ module Faker
         end
       end
 
+      # Return unique values from the generator every time.
+      #
+      # @param max_retries [Integer] The max number of retries that should be done before giving up.
+      # @return [self]
       def unique(max_retries = 10_000)
         @unique ||= UniqueGenerator.new(self, max_retries)
       end
 
-      def sample(list)
-        list.respond_to?(:sample) ? list.sample(random: Faker::Config.random) : list
+      def sample(list, num = nil)
+        if list.respond_to?(:sample)
+          if num
+            list.sample(num, random: Faker::Config.random)
+          else
+            list.sample(random: Faker::Config.random)
+          end
+        else
+          list
+        end
       end
 
       def shuffle(list)
         list.shuffle(random: Faker::Config.random)
       end
 
+      def shuffle!(list)
+        list.shuffle!(random: Faker::Config.random)
+      end
+
       def rand(max = nil)
         if max.nil?
           Faker::Config.random.rand
@@ -247,7 +287,47 @@ module Faker
       end
     end
   end
+
+  if Faker::Config.lazy_loading?
+    def self.load_path(*constants)
+      constants.map do |class_name|
+        class_name
+          .to_s
+          .gsub('::', '/')
+          .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+          .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+          .tr('-', '_')
+          .downcase
+      end.join('/')
+    end
+
+    def self.lazy_load(klass)
+      def klass.const_missing(class_name)
+        load_path = case class_name
+                    when :DnD
+                      Faker.load_path('faker/games/dnd')
+                    else
+                      Faker.load_path(name, class_name)
+                    end
+
+        begin
+          require(load_path)
+        rescue LoadError
+          require(load_path.gsub('faker/', 'faker/default/'))
+        end
+
+        const_get(class_name)
+      end
+    end
+
+    lazy_load(self)
+  end
 end
 
-# require faker objects
-Dir.glob(File.join(File.dirname(__FILE__), 'faker', '/**/*.rb')).sort.each { |file| require file }
+unless Faker::Config.lazy_loading?
+  rb_files = []
+  rb_files << File.join(mydir, 'faker', '*.rb')
+  rb_files << File.join(mydir, 'faker', '/**/*.rb')
+
+  Dir.glob(rb_files).each { |file| require file }
+end

data/lib/helpers/base58.rb

@@ -7,7 +7,7 @@ module Faker
       base = alphabet.size
 
       lv = 0
-      str.split('').reverse.each_with_index { |v, i| lv += v.unpack('C')[0] * 256**i }
+      str.chars.reverse.each_with_index { |v, i| lv += v.unpack1('C') * 256**i }
 
       ret = +''
       while lv.positive?

data/lib/helpers/char.rb

@@ -5,7 +5,7 @@ module Faker
     def self.prepare(string)
       result = romanize_cyrillic string
       result = fix_umlauts result
-      result.gsub(/\W/, '').downcase
+      result.gsub(/[^\w-]/, '').downcase
     end
 
     def self.fix_umlauts(string)
@@ -15,6 +15,7 @@ module Faker
         when 'ö' then 'oe'
         when 'ü' then 'ue'
         when 'ß' then 'ss'
+        else match.downcase
         end
       end
     end
@@ -23,19 +24,16 @@ module Faker
       if Faker::Config.locale == 'uk'
         # Based on conventions abopted by BGN/PCGN for Ukrainian
         uk_chars = {
-          'а' => 'a',  'б' => 'b',  'в' => 'v',  'г' => 'h',  'ґ' => 'g',  'д' => 'd',
-          'е' => 'e',  'є' => 'ye', 'ж' => 'zh', 'з' => 'z',  'и' => 'y',  'і' => 'i',
-          'ї' => 'yi', 'й' => 'y',  'к' => 'k',  'л' => 'l',  'м' => 'm',  'н' => 'n',
-          'о' => 'o',  'п' => 'p',  'р' => 'r',  'с' => 's',  'т' => 't',  'у' => 'u',
-          'ф' => 'f',  'х' => 'kh', 'ц' => 'ts', 'ч' => 'ch', 'ш' => 'sh', 'щ' => 'shch',
-          'ю' => 'yu', 'я' => 'ya',
-          'А' => 'a',  'Б' => 'b',  'В' => 'v',  'Г' => 'h',  'Ґ' => 'g',  'Д' => 'd',
-          'Е' => 'e',  'Є' => 'ye', 'Ж' => 'zh', 'З' => 'z',  'И' => 'y',  'І' => 'i',
-          'Ї' => 'yi', 'Й' => 'y',  'К' => 'k',  'Л' => 'l',  'М' => 'm',  'Н' => 'n',
-          'О' => 'o',  'П' => 'p',  'Р' => 'r',  'С' => 's',  'Т' => 't',  'У' => 'u',
-          'Ф' => 'f',  'Х' => 'kh', 'Ц' => 'ts', 'Ч' => 'ch', 'Ш' => 'sh', 'Щ' => 'shch',
-          'Ю' => 'yu', 'Я' => 'ya',
-          'ь' => '' # Ignore symbol, because its standard presentation is not allowed in URLs
+          'а' => 'a', 'б' => 'b', 'в' => 'v', 'г' => 'h', 'ґ' => 'g', 'д' => 'd', 'е' => 'e',
+          'є' => 'ye', 'ж' => 'zh', 'з' => 'z', 'и' => 'y', 'і' => 'i', 'ї' => 'yi', 'й' => 'y',
+          'к' => 'k',  'л' => 'l', 'м' => 'm', 'н' => 'n', 'о' => 'o', 'п' => 'p', 'р' => 'r',
+          'с' => 's', 'т' => 't', 'у' => 'u', 'ф' => 'f', 'х' => 'kh', 'ц' => 'ts', 'ч' => 'ch',
+          'ш' => 'sh', 'щ' => 'shch', 'ю' => 'yu', 'я' => 'ya', 'А' => 'a', 'Б' => 'b', 'В' => 'v',
+          'Г' => 'h', 'Ґ' => 'g', 'Д' => 'd', 'Е' => 'e', 'Є' => 'ye', 'Ж' => 'zh', 'З' => 'z',
+          'И' => 'y', 'І' => 'i', 'Ї' => 'yi', 'Й' => 'y', 'К' => 'k', 'Л' => 'l', 'М' => 'm',
+          'Н' => 'n', 'О' => 'o', 'П' => 'p', 'Р' => 'r', 'С' => 's', 'Т' => 't', 'У' => 'u',
+          'Ф' => 'f', 'Х' => 'kh', 'Ц' => 'ts', 'Ч' => 'ch', 'Ш' => 'sh', 'Щ' => 'shch', 'Ю' => 'yu',
+          'Я' => 'ya', 'ь' => '' # Ignore symbol, because its standard presentation is not allowed in URLs
         }
         return string.gsub(/[а-яА-ЯіїєґІЇЄҐ]/, uk_chars)
       end
@@ -44,22 +42,19 @@ module Faker
         # Based on conventions abopted by BGN/PCGN for Russian
         ru_chars = {
           'а' => 'a', 'б' => 'b', 'в' => 'v', 'г' => 'h', 'д' => 'd', 'е' => 'e',
-          'ё' => 'ye', 'ж' => 'zh', 'з' => 'z',    'и' => 'i',  'й' => 'y',  'к' => 'k',
-          'л' => 'l',  'м' => 'm',  'н' => 'n',    'о' => 'o',  'п' => 'p',  'р' => 'r',
-          'с' => 's',  'т' => 't',  'у' => 'u',    'ф' => 'f',  'х' => 'kh', 'ц' => 'ts',
-          'ч' => 'ch', 'ш' => 'sh', 'щ' => 'shch', 'ы' => 'у',  'э' => 'e',  'ю' => 'yu',
-          'я' => 'ya',
-          'А' => 'a',  'Б' => 'b',  'В' => 'v',    'Г' => 'h',  'Д' => 'd',  'Е' => 'e',
-          'Ё' => 'ye', 'Ж' => 'zh', 'З' => 'z',    'И' => 'i',  'Й' => 'y',  'К' => 'k',
-          'Л' => 'l',  'М' => 'm',  'Н' => 'n',    'О' => 'o',  'П' => 'p',  'Р' => 'r',
-          'С' => 's',  'Т' => 't',  'У' => 'u',    'Ф' => 'f',  'Х' => 'kh', 'Ц' => 'ts',
-          'Ч' => 'ch', 'Ш' => 'sh', 'Щ' => 'shch', 'Ы' => 'у',  'Э' => 'e',  'Ю' => 'yu',
-          'Я' => 'ya',
-          'ь' => '', 'ъ' => '' # Ignore symbols, because its standard presentation is not allowed in URLs
+          'ё' => 'ye', 'ж' => 'zh', 'з' => 'z', 'и' => 'i', 'й' => 'y', 'к' => 'k',
+          'л' => 'l',  'м' => 'm',  'н' => 'n',  'о' => 'o', 'п' => 'p', 'р' => 'r',
+          'с' => 's',  'т' => 't',  'у' => 'u',  'ф' => 'f', 'х' => 'kh', 'ц' => 'ts',
+          'ч' => 'ch', 'ш' => 'sh', 'щ' => 'shch', 'ы' => 'у', 'э' => 'e', 'ю' => 'yu',
+          'я' => 'ya', 'А' => 'a',  'Б' => 'b', 'В' => 'v', 'Г' => 'h', 'Д' => 'd',
+          'Е' => 'e', 'Ё' => 'ye', 'Ж' => 'zh', 'З' => 'z', 'И' => 'i', 'Й' => 'y',
+          'К' => 'k', 'Л' => 'l', 'М' => 'm', 'Н' => 'n', 'О' => 'o', 'П' => 'p', 'Р' => 'r',
+          'С' => 's',  'Т' => 't',  'У' => 'u', 'Ф' => 'f', 'Х' => 'kh', 'Ц' => 'ts',
+          'Ч' => 'ch', 'Ш' => 'sh', 'Щ' => 'shch', 'Ы' => 'у', 'Э' => 'e', 'Ю' => 'yu',
+          'Я' => 'ya', 'ь' => '', 'ъ' => '' # Ignore symbols, because its standard presentation is not allowed in URLs
         }
         return string.gsub(/[а-яА-Я]/, ru_chars)
       end
-
       string
     end
   end

data/lib/helpers/deprecator.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+# Based on Rails ActiveSupport Deprecator
+# https://github.com/rails/rails/blob/main/activesupport/lib/active_support/deprecation/constant_accessor.rb
+
+# rubocop:disable Style/ClassVars
+module Faker
+  # Provides a way to rename generators, including their namespaces, with a deprecation cycle in which
+  # both the old and new names work, but using the old one prints a deprecation message.
+  #
+  # Deprecator provides a deprecate_generator method to be used when
+  # renaming a generator. For example, let's say we want to change the following Generator's
+  # name to <tt>Faker::NewGenerator</tt>:
+  #
+  #   module Faker
+  #     class Generator
+  #       def self.generate
+  #         "be kind"
+  #       end
+  #     end
+  #   end
+  #
+  # To rename it, you need to do the update the name and declare the deprecation by
+  # including the <tt>Deprecator</tt> module and using the deprecate_generator method:
+  #
+  #   module Faker
+  #     class NewGenerator
+  #       def self.generate
+  #         "be kind"
+  #       end
+  #     end
+  #
+  #     include Deprecator
+  #     deprecate_generator('DeprecatedGenerator', NewGenerator)
+  #   end
+  #
+  # The first argument is a constant name (no colons) as a string. It is the name of
+  # the constant you want to deprecate.
+  #
+  # The second argument is the constant path of the replacement (no colons) as a constant.
+  #
+  # For this to work, a +const_missing+ hook is installed. When users
+  # reference the deprecated constant, the callback prints the
+  # message and constantizes the replacement.
+  #
+  # With that in place, references to <tt>Faker::Deprecator</tt> still work, they
+  # evaluate to <tt>Faker::NewGenerator</tt> now, and trigger a deprecation warning:
+  #
+  #   Faker::Generator.generate
+  #   # DEPRECATION WARNING: Faker::Generator is deprecated. Use Faker::NewGenerator instead
+  #   # "be kind"
+  #
+  # For testing the deprecations, we provide <tt>assert_deprecated</tt>
+  # and <tt>assert_not_deprecated</tt> matchers.
+  #
+  # There's also a <tt>Faker::Deprecator.skip_warning</tt> helper to silence
+  # the deprecation messages in the *test* output. Use it for generators that have lots of tests
+  # to avoid too many noise when running the tests.
+  module Deprecator
+    def self.included(base)
+      extension = Module.new do
+        def const_missing(missing_const_name)
+          if class_variable_defined?(:@@_deprecated_constants) && (replacement = class_variable_get(:@@_deprecated_constants)[missing_const_name.to_s])
+            unless Faker::Deprecator.skip_warning?
+              deprecated_message = "#{name}::#{replacement[:old_generator]} is deprecated."
+              replacement_message = "Use #{replacement[:new_constant]} instead."
+              $stdout.puts("DEPRECATION WARNING: #{deprecated_message} #{replacement_message}")
+            end
+
+            return replacement[:new_constant]
+          end
+
+          super
+        end
+
+        def deprecate_generator(old_generator_name, new_generator_constant)
+          class_variable_set(:@@_deprecated_constants, {}) unless class_variable_defined?(:@@_deprecated_constants)
+          class_variable_get(:@@_deprecated_constants)[old_generator_name] = {
+            new_constant: new_generator_constant,
+            old_generator: old_generator_name
+          }
+        end
+      end
+
+      base.singleton_class.prepend extension
+    end
+
+    # Silence deprecation warnings within the block.
+    #
+    #   Faker::Generator.generate
+    #   # => DEPRECATION WARNING: Faker::Generator is deprecated. Use Faker::NewGenerator instead.
+    #
+    #   Faker::Deprecator.skip_warning do
+    #     Faker::Generator.generate
+    #   end
+    #   # => nil
+    def self.skip_warning
+      original = Faker::Deprecator.skip
+      Faker::Deprecator.skip = true
+      yield
+    ensure
+      Faker::Deprecator.skip = original
+    end
+
+    def self.skip_warning?
+      @skip == true
+    end
+
+    def self.skip
+      @skip ||= false
+    end
+
+    def self.skip=(value)
+      @skip = value
+    end
+  end
+end
+# rubocop:enable Style/ClassVars