ffaker 2.22.0 → 2.24.0

data/lib/ffaker/utils/unique_utils.rb

@@ -16,7 +16,7 @@ module FFaker
       end
 
       def clear
-        instances.values.each(&:clear)
+        instances.each_value(&:clear)
         instances.clear
       end
     end
@@ -32,19 +32,23 @@ module FFaker
 
     private
 
-    def method_missing(name, *arguments)
+    def method_missing(name, *args, **kwargs)
       @max_retries.times do
-        result = @generator.public_send(name, *arguments)
+        result = @generator.public_send(name, *args, **kwargs)
 
-        next if previous_results[[name, arguments]].include?(result)
+        next if previous_results[[name, args, kwargs]].include?(result)
 
-        previous_results[[name, arguments]] << result
+        previous_results[[name, args, kwargs]] << result
         return result
       end
 
       raise RetryLimitExceeded, "Retry limit exceeded for #{name}"
     end
 
+    def respond_to_missing?(name, *args)
+      @generator.respond_to?(name, *args) || super
+    end
+
     def previous_results
       @previous_results ||= Hash.new { |hash, key| hash[key] = Set.new }
     end

data/lib/ffaker/uuid.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require 'date'
+
+module FFaker
+  # UUIDs are a 128-bit value (16 bytes), often represented as a
+  # 32-character hexadecimal string in the format
+  # `xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx`.
+  #
+  # @note This generates lowercase strings, but UUIDs are case-insensitive.
+  #
+  # @see https://www.rfc-editor.org/rfc/rfc4122#section-4
+  # @see https://datatracker.ietf.org/doc/draft-ietf-uuidrev-rfc4122bis/
+  module UUID
+    extend ModuleUtils
+    extend self
+
+    # > UUID version 4 is meant for generating UUIDs from truly-random or
+    # > pseudo-random numbers.
+    def uuidv4
+      uuid = 0
+      # random_a
+      # > The first 48 bits of the layout that can be filled with random data
+      # > as specified in Section 6.9. Occupies bits 0 through 47 (octets 0-5).
+      uuid |= rand((2**48) - 1) << 80
+      # ver
+      # > The 4 bit version field as defined by Section 4.2, set to 0b0100 (4).
+      # > Occupies bits 48 through 51 of octet 6.
+      uuid |= 0b0100 << 76
+      # random_b
+      # > 12 more bits of the layout that can be filled random data as per
+      # > Section 6.9. Occupies bits 52 through 63 (octets 6-7).
+      uuid |= rand((2**12) - 1) << 64
+      # var
+      # > The 2 bit variant field as defined by Section 4.1, set to 0b10.
+      # > Occupies bits 64 and 65 of octet 8.
+      uuid |= 0b10 << 62
+      # random_c
+      # > The final 62 bits of the layout immediately following the var field
+      # > field to be filled with random data as per Section 6.9. Occupies bits
+      # > 66 through 127 (octets 8-15).
+      uuid |= rand((2**62) - 1)
+
+      as_string(uuid)
+    end
+
+    # > UUID version 6 is a field-compatible version of UUIDv1 Section 5.1,
+    # > reordered for improved DB locality. It is expected that UUIDv6 will
+    # > primarily be used in contexts where UUIDv1 is used. Systems that do not
+    # > involve legacy UUIDv1 SHOULD use UUIDv7 instead.
+    def uuidv6
+      timestamp = rand((2**60) - 1)
+
+      uuid = 0
+      # time_high
+      # > The most significant 32 bits of the 60 bit starting timestamp.
+      # > Occupies bits 0 through 31 (octets 0-3).
+      # @note Shifts 28 bits to remove `time_mid` and `time_low`.
+      uuid |= (timestamp >> 28) << 96
+      # time_mid
+      # > The middle 16 bits of the 60 bit starting timestamp. Occupies bits 32
+      # > through 47 (octets 4-5).
+      # @note Shifts 12 bits to remove `time_low`.
+      uuid |= ((timestamp >> 12) & ((2**16) - 1)) << 80
+      # ver
+      # > The 4 bit version field as defined by Section 4.2, set to 0b0110 (6).
+      # > Occupies bits 48 through 51 of octet 6.
+      uuid |= 0b0110 << 76
+      # time_low
+      # > 12 bits that will contain the least significant 12 bits from the 60
+      # > bit starting timestamp. Occupies bits 52 through 63 (octets 6-7).
+      uuid |= (timestamp & ((2**12) - 1)) << 64
+      # var
+      # > The 2 bit variant field as defined by Section 4.1, set to 0b10.
+      # > Occupies bits 64 and 65 of octet 8.
+      uuid |= 0b10 << 62
+      # clk_seq
+      # > The 14 bits containing the clock sequence. Occupies bits 66 through
+      # > 79 (octets 8-9).
+      #
+      # (earlier in the document)
+      # > The clock sequence and node bits SHOULD be reset to a pseudo-random
+      # > value for each new UUIDv6 generated; however, implementations MAY
+      # > choose to retain the old clock sequence and MAC address behavior from
+      # > Section 5.1.
+      uuid |= rand((2**14) - 1) << 48
+      # node
+      # > 48 bit spatially unique identifier. Occupies bits 80 through 127
+      # > (octets 10-15).
+      uuid |= rand((2**48) - 1)
+
+      as_string(uuid)
+    end
+
+    # > UUID version 7 features a time-ordered value field derived from the
+    # > widely implemented and well known Unix Epoch timestamp source, the
+    # > number of milliseconds since midnight 1 Jan 1970 UTC, leap seconds
+    # > excluded. UUIDv7 generally has improved entropy characteristics over
+    # > UUIDv1 Section 5.1 or UUIDv6 Section 5.6.
+    def uuidv7
+      timestamp = rand((2**48) - 1)
+
+      uuid = 0
+      # unix_ts_ms
+      # > 48 bit big-endian unsigned number of Unix epoch timestamp in
+      # > milliseconds as per Section 6.1. Occupies bits 0 through 47 (octets
+      # > 0-5).
+      uuid |= timestamp << 80
+      # ver
+      # > The 4 bit version field as defined by Section 4.2, set to 0b0111 (7).
+      # > Occupies bits 48 through 51 of octet 6.
+      uuid |= 0b0111 << 76
+      # rand_a
+      # > 12 bits pseudo-random data to provide uniqueness as per Section 6.9
+      # > and/or optional constructs to guarantee additional monotonicity as
+      # > per Section 6.2. Occupies bits 52 through 63 (octets 6-7).
+      uuid |= rand((2**12) - 1) << 64
+      # var
+      # > The 2 bit variant field as defined by Section 4.1, set to 0b10.
+      # > Occupies bits 64 and 65 of octet 8.
+      uuid |= 0b10 << 62
+      # rand_b
+      # > The final 62 bits of pseudo-random data to provide uniqueness as per
+      # > Section 6.9 and/or an optional counter to guarantee additional
+      # > monotonicity as per Section 6.2. Occupies bits 66 through 127 (octets
+      # > 8-15).
+      uuid |= rand((2**62) - 1)
+
+      as_string(uuid)
+    end
+
+    # > UUID version 8 provides an RFC-compatible format for experimental or
+    # > vendor-specific use cases. The only requirement is that the variant and
+    # > version bits MUST be set as defined in Section 4.1 and Section 4.2.
+    # > UUIDv8's uniqueness will be implementation-specific and MUST NOT be
+    # > assumed.
+    # >
+    # > [...] To be clear: UUIDv8 is not a replacement for UUIDv4 Section 5.4
+    # > where all 122 extra bits are filled with random data.
+    def uuidv8
+      uuid = 0
+      # custom_a
+      # > The first 48 bits of the layout that can be filled as an
+      # > implementation sees fit. Occupies bits 0 through 47 (octets 0-5).
+      uuid |= rand((2**48) - 1) << 80
+      # ver
+      # > The 4 bit version field as defined by Section 4.2, set to 0b1000 (8).
+      # > Occupies bits 48 through 51 of octet 6.
+      uuid |= 0b1000 << 76
+      # custom_b
+      # > 12 more bits of the layout that can be filled as an implementation
+      # > sees fit. Occupies bits 52 through 63 (octets 6-7).
+      uuid |= rand((2**12) - 1) << 64
+      # var
+      # > The 2 bit variant field as defined by Section 4.1, set to 0b10.
+      # > Occupies bits 64 and 65 of octet 8.
+      uuid |= 0b10 << 62
+      # custom_c
+      # > The final 62 bits of the layout immediately following the var field
+      # > to be filled as an implementation sees fit. Occupies bits 66 through
+      # > 127 (octets 8-15).
+      uuid |= rand((2**62) - 1)
+
+      as_string(uuid)
+    end
+
+    private
+
+    def as_string(uuid)
+      uuid.to_s(16)
+          .rjust(32, '0')
+          .gsub(/(.{8})(.{4})(.{4})(.{4})(.{12})/, '\1-\2-\3-\4-\5')
+    end
+  end
+end

data/lib/ffaker/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module FFaker
-  VERSION = '2.22.0'
+  VERSION = '2.24.0'
 end

data/lib/ffaker.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require_relative 'ffaker/version'
+require 'pathname'
+
 module FFaker
   require_relative 'ffaker/utils/array_utils'
   require_relative 'ffaker/utils/module_utils'
@@ -28,197 +31,64 @@ module FFaker
     letterify(numerify(masks))
   end
 
-  autoload :Address, 'ffaker/address'
-  autoload :AddressAU, 'ffaker/address_au'
-  autoload :AddressBR, 'ffaker/address_br'
-  autoload :AddressCA, 'ffaker/address_ca'
-  autoload :AddressCH, 'ffaker/address_ch'
-  autoload :AddressCHDE, 'ffaker/address_ch_de'
-  autoload :AddressCHFR, 'ffaker/address_ch_fr'
-  autoload :AddressCHIT, 'ffaker/address_ch_it'
-  autoload :AddressDA, 'ffaker/address_da'
-  autoload :AddressDE, 'ffaker/address_de'
-  autoload :AddressFI, 'ffaker/address_fi'
-  autoload :AddressFR, 'ffaker/address_fr'
-  autoload :AddressGR, 'ffaker/address_gr'
-  autoload :AddressID, 'ffaker/address_id'
-  autoload :AddressIN, 'ffaker/address_in'
-  autoload :AddressIT, 'ffaker/address_it'
-  autoload :AddressJA, 'ffaker/address_ja'
-  autoload :AddressKR, 'ffaker/address_kr'
-  autoload :AddressMX, 'ffaker/address_mx'
-  autoload :AddressNL, 'ffaker/address_nl'
-  autoload :AddressPL, 'ffaker/address_pl'
-  autoload :AddressRU, 'ffaker/address_ru'
-  autoload :AddressSE, 'ffaker/address_se'
-  autoload :AddressSN, 'ffaker/address_sn'
-  autoload :AddressUA, 'ffaker/address_ua'
-  autoload :AddressUK, 'ffaker/address_uk'
-  autoload :AddressUS, 'ffaker/address_us'
-  autoload :Airline, 'ffaker/airline'
-  autoload :Animal, 'ffaker/animal'
-  autoload :AnimalBR, 'ffaker/animal_br'
-  autoload :AnimalCN, 'ffaker/animal_cn'
-  autoload :AnimalES, 'ffaker/animal_es'
-  autoload :AnimalPL, 'ffaker/animal_pl'
-  autoload :AnimalUS, 'ffaker/animal_us'
-  autoload :Avatar, 'ffaker/avatar'
-  autoload :AWS, 'ffaker/aws'
-  autoload :BaconIpsum, 'ffaker/bacon_ipsum'
-  autoload :Bank, 'ffaker/bank'
-  autoload :Book, 'ffaker/book'
-  autoload :Boolean, 'ffaker/boolean'
-  autoload :CheesyLingo, 'ffaker/cheesy_lingo'
-  autoload :Code, 'ffaker/code'
-  autoload :Color, 'ffaker/color'
-  autoload :ColorPL, 'ffaker/color_pl'
-  autoload :ColorUA, 'ffaker/color_ua'
-  autoload :Company, 'ffaker/company'
-  autoload :CompanyCN, 'ffaker/company_cn'
-  autoload :CompanyFR, 'ffaker/company_fr'
-  autoload :CompanyIT, 'ffaker/company_it'
-  autoload :CompanyJA, 'ffaker/company_ja'
-  autoload :CompanySE, 'ffaker/company_se'
-  autoload :Conference, 'ffaker/conference'
-  autoload :CoursesFR, 'ffaker/courses_fr'
-  autoload :Currency, 'ffaker/currency'
-  autoload :Date, 'ffaker/date'
-  autoload :DizzleIpsum, 'ffaker/dizzle_ipsum'
-  autoload :Education, 'ffaker/education'
-  autoload :EducationCN, 'ffaker/education_cn'
-  autoload :Filesystem, 'ffaker/filesystem'
-  autoload :Food, 'ffaker/food'
-  autoload :FoodPL, 'ffaker/food_pl'
-  autoload :FreedomIpsum, 'ffaker/freedom_ipsum'
-  autoload :Game, 'ffaker/game'
-  autoload :Gender, 'ffaker/gender'
-  autoload :GenderBR, 'ffaker/gender_br'
-  autoload :GenderCN, 'ffaker/gender_cn'
-  autoload :GenderID, 'ffaker/gender_id'
-  autoload :GenderIT, 'ffaker/gender_it'
-  autoload :GenderJA, 'ffaker/gender_ja'
-  autoload :GenderJP, 'ffaker/gender_jp'
-  autoload :GenderKR, 'ffaker/gender_kr'
-  autoload :GenderPL, 'ffaker/gender_pl'
-  autoload :GenderRU, 'ffaker/gender_ru'
-  autoload :Geolocation, 'ffaker/geolocation'
-  autoload :Guid, 'ffaker/guid'
-  autoload :HealthcareIpsum, 'ffaker/healthcare_ipsum'
-  autoload :HealthcareRU, 'ffaker/healthcare_ru'
-  autoload :HipsterIpsum, 'ffaker/hipster_ipsum'
-  autoload :HTMLIpsum, 'ffaker/html_ipsum'
-  autoload :Identification, 'ffaker/identification'
-  autoload :IdentificationBR, 'ffaker/identification_br'
-  autoload :IdentificationES, 'ffaker/identification_es'
-  autoload :IdentificationESCL, 'ffaker/identification_es_cl'
-  autoload :IdentificationESCO, 'ffaker/identification_es_co'
-  autoload :IdentificationIN, 'ffaker/identification_in'
-  autoload :IdentificationIT, 'ffaker/identification_it'
-  autoload :IdentificationKr, 'ffaker/identification_kr'
-  autoload :IdentificationMX, 'ffaker/identification_mx'
-  autoload :IdentificationPL, 'ffaker/identification_pl'
-  autoload :IdentificationTW, 'ffaker/identification_tw'
-  autoload :IdentificationEC, 'ffaker/identification_ec'
-  autoload :Image, 'ffaker/image'
-  autoload :Internet, 'ffaker/internet'
-  autoload :InternetSE, 'ffaker/internet_se'
-  autoload :Job, 'ffaker/job'
-  autoload :JobBR, 'ffaker/job_br'
-  autoload :JobCN, 'ffaker/job_cn'
-  autoload :JobFR, 'ffaker/job_fr'
-  autoload :JobIT, 'ffaker/job_it'
-  autoload :JobJA, 'ffaker/job_ja'
-  autoload :JobKR, 'ffaker/job_kr'
-  autoload :JobVN, 'ffaker/job_vn'
-  autoload :JoJo, 'ffaker/jo_jo'
-  autoload :Locale, 'ffaker/locale'
-  autoload :Lorem, 'ffaker/lorem'
-  autoload :LoremAR, 'ffaker/lorem_ar'
-  autoload :LoremBR, 'ffaker/lorem_br'
-  autoload :LoremCN, 'ffaker/lorem_cn'
-  autoload :LoremFR, 'ffaker/lorem_fr'
-  autoload :LoremIE, 'ffaker/lorem_ie'
-  autoload :LoremIT, 'ffaker/lorem_it'
-  autoload :LoremJA, 'ffaker/lorem_ja'
-  autoload :LoremKR, 'ffaker/lorem_kr'
-  autoload :LoremPL, 'ffaker/lorem_pl'
-  autoload :LoremRU, 'ffaker/lorem_ru'
-  autoload :LoremUA, 'ffaker/lorem_ua'
-  autoload :Movie, 'ffaker/movie'
-  autoload :Music, 'ffaker/music'
-  autoload :Name, 'ffaker/name'
-  autoload :NameAR, 'ffaker/name_ar'
-  autoload :NameBR, 'ffaker/name_br'
-  autoload :NameCN, 'ffaker/name_cn'
-  autoload :NameCS, 'ffaker/name_cs'
-  autoload :NameDA, 'ffaker/name_da'
-  autoload :NameDE, 'ffaker/name_de'
-  autoload :NameES, 'ffaker/name_es'
-  autoload :NameFR, 'ffaker/name_fr'
-  autoload :NameGA, 'ffaker/name_ga'
-  autoload :NameGR, 'ffaker/name_gr'
-  autoload :NameID, 'ffaker/name_id'
-  autoload :NameIN, 'ffaker/name_in'
-  autoload :NameIT, 'ffaker/name_it'
-  autoload :NameJA, 'ffaker/name_ja'
-  autoload :NameKH, 'ffaker/name_kh'
-  autoload :NameKR, 'ffaker/name_kr'
-  autoload :NameMX, 'ffaker/name_mx'
-  autoload :NameNB, 'ffaker/name_nb'
-  autoload :NameNL, 'ffaker/name_nl'
-  autoload :NamePH, 'ffaker/name_ph'
-  autoload :NamePL, 'ffaker/name_pl'
-  autoload :NameRU, 'ffaker/name_ru'
-  autoload :NameSE, 'ffaker/name_se'
-  autoload :NameSN, 'ffaker/name_sn'
-  autoload :NameTH, 'ffaker/name_th'
-  autoload :NameTW, 'ffaker/name_tw'
-  autoload :NameTHEN, 'ffaker/name_th_en'
-  autoload :NameUA, 'ffaker/name_ua'
-  autoload :NameVN, 'ffaker/name_vn'
-  autoload :NatoAlphabet, 'ffaker/nato_alphabet'
-  autoload :Number, 'ffaker/number'
-  autoload :PhoneNumber, 'ffaker/phone_number'
-  autoload :PhoneNumberAU, 'ffaker/phone_number_au'
-  autoload :PhoneNumberBR, 'ffaker/phone_number_br'
-  autoload :PhoneNumberCH, 'ffaker/phone_number_ch'
-  autoload :PhoneNumberCU, 'ffaker/phone_number_cu'
-  autoload :PhoneNumberDA, 'ffaker/phone_number_da'
-  autoload :PhoneNumberDE, 'ffaker/phone_number_de'
-  autoload :PhoneNumberFR, 'ffaker/phone_number_fr'
-  autoload :PhoneNumberID, 'ffaker/phone_number_id'
-  autoload :PhoneNumberIT, 'ffaker/phone_number_it'
-  autoload :PhoneNumberJA, 'ffaker/phone_number_ja'
-  autoload :PhoneNumberKR, 'ffaker/phone_number_kr'
-  autoload :PhoneNumberMX, 'ffaker/phone_number_mx'
-  autoload :PhoneNumberNL, 'ffaker/phone_number_nl'
-  autoload :PhoneNumberPL, 'ffaker/phone_number_pl'
-  autoload :PhoneNumberSE, 'ffaker/phone_number_se'
-  autoload :PhoneNumberSG, 'ffaker/phone_number_sg'
-  autoload :PhoneNumberSN, 'ffaker/phone_number_sn'
-  autoload :PhoneNumberTW, 'ffaker/phone_number_tw'
-  autoload :PhoneNumberUA, 'ffaker/phone_number_ua'
-  autoload :PhoneNumberRU, 'ffaker/phone_number_ru'
-  autoload :Product, 'ffaker/product'
-  autoload :SemVer, 'ffaker/sem_ver'
-  autoload :Skill, 'ffaker/skill'
-  autoload :Sport, 'ffaker/sport'
-  autoload :SportPL, 'ffaker/sport_pl'
-  autoload :SportUS, 'ffaker/sport_us'
-  autoload :SportRU, 'ffaker/sport_ru'
-  autoload :SSN, 'ffaker/ssn'
-  autoload :SSNMX, 'ffaker/ssn_mx'
-  autoload :SSNSE, 'ffaker/ssn_se'
-  autoload :String, 'ffaker/string'
-  autoload :Time, 'ffaker/time'
-  autoload :Tweet, 'ffaker/tweet'
-  autoload :Unit, 'ffaker/unit'
-  autoload :UnitEnglish, 'ffaker/unit_english'
-  autoload :UnitMetric, 'ffaker/unit_metric'
-  autoload :VERSION, 'ffaker/version'
-  autoload :Vehicle, 'ffaker/vehicle'
-  autoload :Venue, 'ffaker/venue'
-  autoload :Youtube, 'ffaker/youtube'
+  autoload_acronyms = {
+    'ar' => 'AR',
+    'au' => 'AU',
+    'aws' => 'AWS',
+    'br' => 'BR',
+    'ca' => 'CA',
+    'ch' => 'CH',
+    'cl' => 'CL',
+    'cn' => 'CN',
+    'co' => 'CO',
+    'cs' => 'CS',
+    'cu' => 'CU',
+    'da' => 'DA',
+    'de' => 'DE',
+    'ec' => 'EC',
+    'en' => 'EN',
+    'es' => 'ES',
+    'fi' => 'FI',
+    'fr' => 'FR',
+    'ga' => 'GA',
+    'gr' => 'GR',
+    'html' => 'HTML',
+    'id' => 'ID',
+    'ie' => 'IE',
+    'in' => 'IN',
+    'it' => 'IT',
+    'ja' => 'JA',
+    'jp' => 'JP',
+    'kh' => 'KH',
+    'kr' => 'KR',
+    'mx' => 'MX',
+    'nb' => 'NB',
+    'nl' => 'NL',
+    'ph' => 'PH',
+    'pl' => 'PL',
+    'ru' => 'RU',
+    'se' => 'SE',
+    'sg' => 'SG',
+    'sn' => 'SN',
+    'ssn' => 'SSN',
+    'th' => 'TH',
+    'tw' => 'TW',
+    'ua' => 'UA',
+    'uk' => 'UK',
+    'us' => 'US',
+    'uuid' => 'UUID',
+    'vn' => 'VN'
+  }
+
+  directory = "#{__dir__}/ffaker"
+  Dir["#{directory}/*.rb"].each do |file_name|
+    relative_file_path = Pathname.new(file_name).relative_path_from(directory).to_s.chomp('.rb')
+    ## Don't consider files in sub-directories
+    constant_name = relative_file_path.split('_').map do |part|
+      autoload_acronyms.fetch(part) { part.capitalize }
+    end.join
+    autoload constant_name, file_name
+  end
 
   # Random Number Generator (RNG) used with ModuleUtils#fetch, #shuffle, #rand
   # in order to provide deterministic repeatability.

data/scripts/reference.rb

@@ -11,8 +11,8 @@ ICONS = {
   warning: '❗'
 }.freeze
 
-UTILS_MODULES = %i[ArrayUtils ModuleUtils RandomUtils Random]
-UTILS_METHODS = %i[k underscore fetch_sample rand shuffle unique luhn_check]
+UTILS_MODULES = %i[ArrayUtils ModuleUtils RandomUtils Random Version].freeze
+UTILS_METHODS = %i[k underscore fetch_sample rand shuffle unique luhn_check].freeze
 
 # Get a list of sections
 def faker_modules
@@ -36,12 +36,14 @@ end
 # Catch deprecation warnings.
 # This `#warn` overrides Kernel#warn
 def warn(msg)
-  $warnings << msg if $warnings
+  return unless Kernel.instance_variable_get(:@ffaker_warnings)
+
+  Kernel.instance_variable_set(:@ffaker_warnings, Kernel.instance_variable_get(:@ffaker_warnings) << msg)
 end
 
 def catch_warnings
-  $warnings = []
-  [yield, $warnings]
+  Kernel.instance_variable_set(:@ffaker_warnings, [])
+  [yield, Kernel.instance_variable_get(:@ffaker_warnings)]
 end
 
 def escape(str)
@@ -70,11 +72,7 @@ sections = faker_modules.map do |mod|
         examples, warnings = catch_warnings do
           Array.new(3) { mod.unique.send meth }
         end
-        right = if warnings.any?
-                  "#{ICONS[:warning]} *#{warnings.first}*"
-                else
-                  (escape examples.join(', ')).to_s
-                end
+        right = warnings.any? ? "#{ICONS[:warning]} *#{warnings.first}*" : (escape examples.join(', ')).to_s
       rescue StandardError => e
         right = "#{ICONS[:error]} #{e.class}: #{e.message}"
       end

data/test/helper.rb

@@ -14,7 +14,7 @@ module DeterministicHelper
   # the internal Random Number Generator state and compared the results of
   # each execution to make sure they are the same.
   def assert_deterministic(options = {}, &block)
-    raise ArgumentError, 'Must pass a block' unless block_given?
+    raise ArgumentError, 'Must pass a block' unless block
 
     options = { message: 'Results are not repeatable' }.merge(options)
 
@@ -35,7 +35,7 @@ module DeterministicHelper
       end
     operator_name += '_or_equal_to' if operator[1] == '='
 
-    define_method "assert_#{operator_name}" do |got, expected|
+    define_method :"assert_#{operator_name}" do |got, expected|
       assert(
         got.public_send(operator, expected),
         "Expected #{operator} \"#{expected}\", but got #{got}"
@@ -56,8 +56,8 @@ module DeterministicHelper
   end
 
   %w[less_than_or_equal_to between].each do |method_name|
-    define_method "assert_random_#{method_name}" do |*args, &block|
-      assert_random(block) { send "assert_#{method_name}", block.call, *args }
+    define_method :"assert_random_#{method_name}" do |*args, &block|
+      assert_random(block) { send :"assert_#{method_name}", block.call, *args }
     end
   end
 
@@ -76,7 +76,7 @@ module DeterministicHelper
     #  }
     def assert_methods_are_deterministic(klass, *methods)
       Array(methods).each do |meth|
-        define_method "test_#{meth}_is_deterministic" do
+        define_method :"test_#{meth}_is_deterministic" do
           assert_deterministic(message: "Results from `#{klass}.#{meth}` are not repeatable") do
             klass.send(meth)
           end

data/test/test_avatar.rb

@@ -18,40 +18,63 @@ class TestAvatar < Test::Unit::TestCase
                  @tester.image)
   end
 
+  def test_image_output_with_keyword_arguments
+    output = capture_output do
+      @tester.image(format: 'jpg')
+    end
+
+    assert_equal ['', ''], output
+  end
+
+  def test_image_with_slug_as_positional_argument
+    assert_equal("#{ROBOHASH}/foobar.png?size=300x300", @tester.image('foobar'))
+  end
+
+  def test_image_output_with_positional_arguments
+    output = capture_output do
+      @tester.image('foobar')
+    end
+
+    assert_equal(
+      ['', "Positional arguments for Avatar#image are deprecated. Please use keyword arguments.\n"],
+      output
+    )
+  end
+
   def test_avatar_with_param
-    assert_equal("#{ROBOHASH}/faker.png?size=300x300", @tester.image('faker'))
+    assert_equal("#{ROBOHASH}/faker.png?size=300x300", @tester.image(slug: 'faker'))
   end
 
   def test_avatar_with_correct_size
     assert_equal("#{ROBOHASH}/faker.png?size=150x320",
-                 @tester.image('faker', '150x320'))
+                 @tester.image(slug: 'faker', size: '150x320'))
   end
 
   def test_avatar_with_incorrect_size
     assert_raise ArgumentError do
-      @tester.image(nil, '150x320z')
+      @tester.image(size: '150x320z')
     end
   end
 
   def test_avatar_with_supported_format
     assert_equal("#{ROBOHASH}/faker.jpg?size=300x300",
-                 @tester.image('faker', '300x300', 'jpg'))
+                 @tester.image(slug: 'faker', size: '300x300', format: 'jpg'))
   end
 
   def test_avatar_with_incorrect_format
     assert_raise ArgumentError do
-      @tester.image(nil, '300x300', 'wrong_format')
+      @tester.image(size: '300x300', format: 'wrong_format')
     end
   end
 
   def test_avatar_with_correct_background
     assert_equal("#{ROBOHASH}/faker.png?size=300x300&bgset=bg1",
-                 @tester.image('faker', '300x300', 'png', '1'))
+                 @tester.image(slug: 'faker', size: '300x300', format: 'png', bgset: '1'))
   end
 
   def test_avatar_with_incorrect_background
     assert_raise ArgumentError do
-      @tester.image('faker', '300x300', 'png', 'not_a_number')
+      @tester.image(slug: 'faker', size: '300x300', format: 'png', bgset: 'not_a_number')
     end
   end
 end