ffaker 2.20.0 → 2.25.0

data/lib/ffaker/string.rb

@@ -21,7 +21,7 @@ module FFaker
       @last_token = nil
 
       # Drop surrounding /'s and split into characters
-      tokens = exp.inspect[1...-1].split(//)
+      tokens = exp.inspect[1...-1].chars
       result << process_token(tokens) until tokens.empty?
 
       result
@@ -53,15 +53,15 @@ module FFaker
       when '?'
         # TODO: Let ? generate nothing
         '' # We already printed its target
-      when '+' then
+      when '+'
         tokens.unshift(token) if rand(0..1) == 1 # Leave the `+` on to run again
         process_token(@last_token) # Run the last one at least once
-      when '*' then
+      when '*'
         tokens.unshift(token) if rand(0..1) == 1 # Leave the `*` on to run again
         return '' if rand(0..1) == 1 # Or maybe do nothing
 
         process_token(@last_token) # Else run the last one again
-      when '{' then
+      when '{'
         number = +''
         while (ch = tokens.shift) != '}'
           number << ch
@@ -76,14 +76,14 @@ module FFaker
 
     def generate_token(token, tokens)
       case token
-      when /\w/ then
+      when /\w/
         @last_token = [token]
         token
-      when BACKSLASH then
+      when BACKSLASH
         token = tokens.shift
         @last_token = ['\\', token]
         special(token)
-      when '[' then
+      when '['
         set = []
         while (ch = tokens.shift) != ']'
           set << ch

data/lib/ffaker/time.rb

@@ -22,17 +22,17 @@ module FFaker
 
     def datetime(params = {})
       years_back = params[:year_range] || 5
-      latest_year = params [:year_latest] || 0
+      latest_year = params[:year_latest] || 0
       year = (rand * years_back).ceil + (::DateTime.now.year - latest_year - years_back)
       month = rand(1..12)
-      day = rand(1..Date.new(year, month, -1).day)
+      day = rand(1..::Date.new(year, month, -1).day)
       hours = params[:hours] || rand(0..23)
       minutes = params[:minutes] || rand(0..59)
       series = [date = ::DateTime.new(year, month, day, hours, minutes)]
       return date unless params[:series]
 
       params[:series].each do |some_time_after|
-        series << series.last + (rand * some_time_after).ceil
+        series << (series.last + (rand * some_time_after).ceil)
       end
       series
     end
@@ -44,7 +44,7 @@ module FFaker
     def between(from, to)
       from_value = convert_to_time(from)
       to_value = convert_to_time(to)
-      ::Time.at(from_value + rand * (to_value.to_f - from_value.to_f))
+      ::Time.at(from_value + (rand * (to_value.to_f - from_value.to_f)))
     end
 
     private

data/lib/ffaker/tweet.rb

@@ -19,7 +19,7 @@ module FFaker
       }.merge(args)
 
       my_reply = options[:reply] ? "#{mention} " : ''
-      my_mentions = (options[:num_mentions]).positive? ? "#{mentions(options[:num_mentions])} " : ''
+      my_mentions = options[:num_mentions].positive? ? "#{mentions(options[:num_mentions])} " : ''
       my_tags = tags(options[:num_hashtags])
 
       remaining = [

data/lib/ffaker/utils/module_utils.rb

@@ -13,8 +13,8 @@ module FFaker
     end
 
     def const_missing(const_name)
-      if const_name =~ /[a-z]/ # Not a constant, probably a class/module name.
-        super const_name
+      if const_name.match?(/[a-z]/) # Not a constant, probably a class/module name.
+        super
       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)}"
@@ -25,7 +25,7 @@ module FFaker
     end
 
     def underscore(string)
-      string.gsub(/::/, '/')
+      string.gsub('::', '/')
             .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
             .gsub(/([a-z\d])([A-Z])/, '\1_\2')
             .tr('-', '_')
@@ -33,27 +33,17 @@ module FFaker
     end
 
     def unique(max_retries = 10_000)
-      @unique_generator ||= FFaker::UniqueUtils.new(self, max_retries)
+      FFaker::UniqueUtils.add_instance(self, max_retries)
     end
 
     # http://en.wikipedia.org/wiki/Luhn_algorithm
     def luhn_check(number)
-      multiplications = []
-
-      number.split(//).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/utils/unique_utils.rb

@@ -1,43 +1,56 @@
 # frozen_string_literal: true
 
+require 'set'
+
 module FFaker
   class UniqueUtils
-    def initialize(generator, max_retries)
-      @generator = generator
-      @max_retries = max_retries
-      @previous_results = Hash.new { |hash, key| hash[key] = Set.new }
-    end
+    RetryLimitExceeded = Class.new(StandardError)
 
-    def method_missing(name, *arguments)
-      @generator.respond_to?(name) ? add_results_to_hash(name, *arguments) : super
-    end
+    class << self
+      def add_instance(generator, max_retries)
+        instances[generator] ||= FFaker::UniqueUtils.new(generator, max_retries)
+      end
 
-    def respond_to_missing?(method_name, include_private = false)
-      super
-    end
+      def instances
+        Thread.current[:ffaker_unique_utils] ||= {}
+      end
 
-    RetryLimitExceeded = Class.new(StandardError)
+      def clear
+        instances.each_value(&:clear)
+        instances.clear
+      end
+    end
 
-    def clear
-      @previous_results.clear
+    def initialize(generator, max_retries)
+      @generator = generator
+      @max_retries = max_retries
     end
 
-    def self.clear
-      ObjectSpace.each_object(self, &:clear)
+    def clear
+      previous_results.clear
     end
 
     private
 
-    def add_results_to_hash(name, *arguments)
+    def method_missing(name, *args, **kwargs)
       @max_retries.times do
-        result = @generator.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
+
+      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
   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/vehicle.rb

@@ -2,6 +2,68 @@
 
 module FFaker
   module Vehicle
+    module VIN
+      extend ModuleUtils
+      extend self
+
+      # https://en.wikibooks.org/wiki/Vehicle_Identification_Numbers_(VIN_codes)/World_Manufacturer_Identifier_(WMI)
+      VALID_WMI_REGIONS = [*'A'..'C', *'J'..'N', 'P', *'R'..'Z', *'1'..'9'].freeze
+
+      VALID_YEAR_CHARS = %w[
+        5 6 7 8 9 A B C D E F G H J K L M N P R S T V W X Y 1 2 3 4 5 6 7 8 9
+      ].freeze # 2005-2039
+
+      # https://en.wikibooks.org/wiki/Vehicle_Identification_Numbers_(VIN_codes)/Check_digit
+      TRANSLITERATION_VALUES = {
+        'A' => 1, 'B' => 2, 'C' => 3, 'D' => 4, 'E' => 5, 'F' => 6, 'G' => 7, 'H' => 8,
+        'J' => 1, 'K' => 2, 'L' => 3, 'M' => 4, 'N' => 5, 'P' => 7, 'R' => 9,
+        'S' => 2, 'T' => 3, 'U' => 4, 'V' => 5, 'W' => 6, 'X' => 7, 'Y' => 8, 'Z' => 9
+      }.freeze
+      POSITION_WEIGHTS = [8, 7, 6, 5, 4, 3, 2, 10, 0, 9, 8, 7, 6, 5, 4, 3, 2].freeze
+
+      VALID_ALPHA = TRANSLITERATION_VALUES.keys
+      VALID_ALPHANUMERIC = [*VALID_ALPHA, *'1'..'9'].freeze
+
+      # Generate a VIN that is compliant with specifications of US Title 49 Section 565.15
+      # https://www.govinfo.gov/content/pkg/CFR-2019-title49-vol6/xml/CFR-2019-title49-vol6-part565.xml#seqnum565.15
+      #
+      # Position  Meaning
+      # 1-3       Manufacturer ID aka WMI (alpha and digits)
+      # 4-8       Vehicle Description ("For passenger cars ..[position 7].. shall be alphabetic")
+      # 9         Check Digit (0-9 or "X")
+      # 10        Year (see VIN_VALID_YEARS)
+      # 11        Plant of manufacture (alpha and digits)
+      # 12-17     Serial number (digits only)
+      #
+      # I, O and Q are NOT allowed. VIN_VALID_ALPHA has valid alpha characters.
+      def vin
+        generated_vin = [
+          # Manufacturer ID / WMI
+          fetch_sample(VALID_WMI_REGIONS),
+          fetch_sample(VALID_ALPHANUMERIC, count: 2),
+          # Vehicle Description
+          fetch_sample(VALID_ALPHANUMERIC, count: 3),
+          fetch_sample(VALID_ALPHA),
+          fetch_sample(VALID_ALPHANUMERIC),
+          '0', # check digit placeholder
+          fetch_sample(VALID_YEAR_CHARS), # Year of Manufacture
+          fetch_sample(VALID_ALPHANUMERIC), # Plant ID
+          FFaker.numerify('######') # Serial Number
+        ].join
+
+        # Calculate the Check Digit
+        weighted_sum = generated_vin.chars.each_with_index.sum do |char, idx|
+          (TRANSLITERATION_VALUES[char] || char).to_i * POSITION_WEIGHTS[idx]
+        end
+
+        check_digit = weighted_sum % 11
+        check_digit = 'X' if check_digit == 10
+        generated_vin[8] = check_digit.to_s
+
+        generated_vin
+      end
+    end
+
     extend ModuleUtils
     extend self
 
@@ -37,7 +99,7 @@ module FFaker
     end
 
     def vin
-      FFaker.bothify('1#???#####?######').upcase
+      VIN.vin
     end
 
     def year

data/lib/{version.rb → ffaker/version.rb}

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