ffaker 2.23.0 → 2.24.0

data/lib/ffaker/bank_us.rb

@@ -5,12 +5,16 @@ module FFaker
     extend ModuleUtils
     extend self
 
+    ROUTING_NUMBER_PREFIXES = [*'00'..'12', *'21'..'32', *'61'..'72', '80'].freeze
+
     def account_number(min_digits: 9, max_digits: 17)
       FFaker.numerify('#' * rand(min_digits..max_digits))
     end
 
     def routing_number
-      partial_routing_number = FFaker.numerify('########')
+      first_two_digits = fetch_sample(ROUTING_NUMBER_PREFIXES)
+
+      partial_routing_number = FFaker.numerify("#{first_two_digits}######")
       ninth_digit = generate_ninth_digit(partial_routing_number)
 
       "#{partial_routing_number}#{ninth_digit}"

data/lib/ffaker/guid.rb

@@ -5,8 +5,14 @@ module FFaker
     extend ModuleUtils
     extend self
 
+    # Because this method uses arbitrary hexadecimal characters it is likely to
+    # generate invalid UUIDs--UUIDs must have a version (1-8) at bits 48-51,
+    # and bits 64-65 must be 0b10.
+    #
+    # @deprecated Often generates invalid UUIDs. Use {UUID} instead.
     def guid
-      FFaker.hexify('########-####-####-####-############')
+      warn '[guid] is deprecated. Use the UUID.uuidv4 method instead.'
+      FFaker::UUID.uuidv4.upcase
     end
   end
 end

data/lib/ffaker/name_pl.rb

@@ -90,9 +90,9 @@ module FFaker
 
     def name_for_gender(name_type, gender) # :nodoc:
       raise(ArgumentError, "Gender must be one of: #{GENDERS}") unless GENDERS.include?(gender)
-      return send("#{gender}_#{name_type}") unless gender == :random
+      return send(:"#{gender}_#{name_type}") unless gender == :random
 
-      fetch_sample([send("female_#{name_type}"), send("male_#{name_type}")])
+      fetch_sample([send(:"female_#{name_type}"), send(:"male_#{name_type}")])
     end
   end
 end

data/lib/ffaker/utils/module_utils.rb

@@ -14,7 +14,7 @@ module FFaker
 
     def const_missing(const_name)
       if const_name.match?(/[a-z]/) # Not a constant, probably a class/module name.
-        super const_name
+        super(const_name)
       else
         mod_name = ancestors.first.to_s.split('::').last
         data_path = "#{FFaker::BASE_LIB_PATH}/ffaker/data/#{underscore(mod_name)}/#{underscore(const_name.to_s)}"
@@ -38,21 +38,12 @@ module FFaker
 
     # http://en.wikipedia.org/wiki/Luhn_algorithm
     def luhn_check(number)
-      multiplications = []
-
-      number.chars.each_with_index do |digit, i|
-        multiplications << i.even? ? digit.to_i * 2 : digit.to_i
-      end
-
-      sum = 0
-      multiplications.each do |num|
-        num.to_s.each_byte do |character|
-          sum += character.chr.to_i
-        end
-      end
-
-      control_digit = (sum % 10).zero? ? 0 : (((sum / 10) + 1) * 10) - sum
-      control_digit.to_s
+      sum = number.chars
+                  .map(&:to_i)
+                  .reverse
+                  .each_with_index
+                  .sum { |digit, index| index.even? ? (2 * digit).digits.sum : digit }
+      ((10 - (sum % 10)) % 10).to_s
     end
   end
 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.23.0'
+  VERSION = '2.24.0'
 end

data/lib/ffaker.rb

@@ -76,6 +76,7 @@ module FFaker
     'ua' => 'UA',
     'uk' => 'UK',
     'us' => 'US',
+    'uuid' => 'UUID',
     'vn' => 'VN'
   }
 

data/test/helper.rb

@@ -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_bank_us.rb

@@ -24,6 +24,8 @@ class TestBankUS < Test::Unit::TestCase
     routing_number = @tester.routing_number
     assert_match(/\A\d{9}\z/, routing_number)
 
+    assert_true(@tester::ROUTING_NUMBER_PREFIXES.include?(routing_number[0..1]))
+
     checksum = (
       (7 * (routing_number[0].to_i + routing_number[3].to_i + routing_number[6].to_i)) +
         (3 * (routing_number[1].to_i + routing_number[4].to_i + routing_number[7].to_i)) +

data/test/test_guid.rb

@@ -8,7 +8,7 @@ class TestGuid < Test::Unit::TestCase
   assert_methods_are_deterministic(FFaker::Guid, :guid)
 
   def test_guid
-    assert_match(/[A-F0-9]{8}-[A-F0-9]{4}-[A-F0-9]{4}-[A-F0-9]{4}-[A-F0-9]{12}/,
+    assert_match(/\A[0-9A-F]{8}-[0-9A-F]{4}-4[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}\z/,
                  FFaker::Guid.guid)
   end
 end

data/test/test_module_utils.rb

@@ -44,4 +44,13 @@ class TestModuleUtils < Test::Unit::TestCase
     FFaker::UniqueUtils.clear
     generator.unique.test
   end
+
+  def test_luhn_check
+    obj = Object.new
+    obj.extend FFaker::ModuleUtils
+    assert obj.luhn_check('97248708') == '6'
+    assert obj.luhn_check('1789372997') == '4'
+    assert obj.luhn_check('8899982700037') == '1'
+    assert obj.luhn_check('1234567820001') == '0'
+  end
 end

data/test/test_uuid.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestUUID < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::UUID,
+    :uuidv4, :uuidv6, :uuidv7, :uuidv8
+  )
+
+  def setup
+    @tester = FFaker::UUID
+  end
+
+  # @see https://stackoverflow.com/a/38191104
+  def test_uuidv4
+    raw_uuid = @tester.uuidv4
+    assert_format(raw_uuid)
+
+    uuid = uuid_to_integer(raw_uuid)
+    assert_version(uuid, 0b0100)
+    assert_variant(uuid, 0b10)
+  end
+
+  def test_uuidv6
+    raw_uuid = @tester.uuidv6
+    assert_format(raw_uuid)
+
+    uuid = uuid_to_integer(raw_uuid)
+    assert_version(uuid, 0b0110)
+    assert_variant(uuid, 0b10)
+  end
+
+  def test_uuidv7
+    raw_uuid = @tester.uuidv7
+    assert_format(raw_uuid)
+
+    uuid = uuid_to_integer(raw_uuid)
+    assert_version(uuid, 0b0111)
+    assert_variant(uuid, 0b10)
+  end
+
+  def test_uuidv8
+    raw_uuid = @tester.uuidv8
+    assert_format(raw_uuid)
+
+    uuid = uuid_to_integer(raw_uuid)
+    assert_version(uuid, 0b1000)
+    assert_variant(uuid, 0b10)
+  end
+
+  private
+
+  # Matches structure of all UUID versions.
+  def assert_format(uuid)
+    assert_match(/\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\z/,
+                 uuid)
+  end
+
+  def assert_version(uuid, version)
+    assert_equal(version, (uuid >> 76) & 0b1111)
+  end
+
+  def assert_variant(uuid, variant)
+    assert_equal(variant, (uuid >> 62) & 0b11)
+  end
+
+  def uuid_to_integer(uuid)
+    uuid.delete('-').to_i(16)
+  end
+end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: ffaker
 version: !ruby/object:Gem::Version
-  version: 2.23.0
+  version: 2.24.0
 platform: ruby
 authors:
 - https://github.com/ffaker/ffaker/graphs/contributors
 - Emmanuel Oga
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-09-19 00:00:00.000000000 Z
+date: 2025-02-02 00:00:00.000000000 Z
 dependencies: []
 description: Ffaker generates dummy data.
 email: EmmanuelOga@gmail.com
@@ -587,6 +587,7 @@ files:
 - lib/ffaker/utils/module_utils.rb
 - lib/ffaker/utils/random_utils.rb
 - lib/ffaker/utils/unique_utils.rb
+- lib/ffaker/uuid.rb
 - lib/ffaker/vehicle.rb
 - lib/ffaker/venue.rb
 - lib/ffaker/version.rb
@@ -788,6 +789,7 @@ files:
 - test/test_units.rb
 - test/test_units_english.rb
 - test/test_units_metric.rb
+- test/test_uuid.rb
 - test/test_vehicle.rb
 - test/test_venue.rb
 - test/test_youtube.rb
@@ -798,7 +800,7 @@ metadata:
   changelog_uri: https://github.com/ffaker/ffaker/blob/main/Changelog.md
   documentation_uri: https://github.com/ffaker/ffaker/blob/main/REFERENCE.md
   rubygems_mfa_required: 'true'
-post_install_message: 
+post_install_message:
 rdoc_options:
 - "--charset=UTF-8"
 require_paths:
@@ -814,8 +816,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
-signing_key: 
+rubygems_version: 3.4.19
+signing_key:
 specification_version: 4
 summary: Ffaker generates dummy data.
 test_files: []