mini-fast-rb 0.0.1

data/ffaker-2.25.0/lib/ffaker/utils/array_utils.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative 'random_utils'
+
+module FFaker
+  module ArrayUtils
+    extend RandomUtils
+
+    def self.const_array(argument)
+      array = argument.is_a?(Array) ? argument : argument.to_a
+      array.extend ArrayUtils
+      freeze_all(array)
+    end
+
+    def self.random_pick(array, num)
+      warn '[ArrayUtils.random_pick] is deprecated. Please use the ModuleUtils#fetch_sample method'
+      fetch_sample(array, count: num)
+    end
+
+    def self.rand(array)
+      warn '[ArrayUtils.rand] is deprecated. Please use the ModuleUtils#fetch_sample method'
+      fetch_sample(array)
+    end
+
+    def self.freeze_all(array)
+      array.each(&:freeze)
+      array.freeze
+      array
+    end
+
+    def self.shuffle(array)
+      array.sort_by { FFaker::Random.rand }
+    end
+
+    def random_pick(num)
+      warn '[ArrayUtils#random_pick] is deprecated. Please use the ModuleUtils#fetch_sample method'
+      ArrayUtils.random_pick(self, num)
+    end
+
+    def rand
+      warn '[ArrayUtils#rand] is deprecated. Please use the ModuleUtils#fetch_sample method'
+      ArrayUtils.rand(self)
+    end
+
+    def freeze_all
+      ArrayUtils.freeze_all(self)
+    end
+
+    def shuffle
+      ArrayUtils.shuffle(self)
+    end
+  end
+end

data/ffaker-2.25.0/lib/ffaker/utils/module_utils.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative 'array_utils'
+require_relative 'random_utils'
+require_relative 'unique_utils'
+
+module FFaker
+  module ModuleUtils
+    include RandomUtils
+
+    def k(arg)
+      FFaker::ArrayUtils.const_array(arg)
+    end
+
+    def const_missing(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)}"
+        data = k File.read(data_path, mode: 'r:UTF-8').split("\n")
+        const_set const_name, data
+        data
+      end
+    end
+
+    def underscore(string)
+      string.gsub('::', '/')
+            .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+            .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+            .tr('-', '_')
+            .downcase
+    end
+
+    def unique(max_retries = 10_000)
+      FFaker::UniqueUtils.add_instance(self, max_retries)
+    end
+
+    # http://en.wikipedia.org/wiki/Luhn_algorithm
+    def luhn_check(number)
+      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/ffaker-2.25.0/lib/ffaker/utils/random_utils.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module FFaker
+  # Methods for returning repeatably-random data using the internal
+  # Random Number Generator. You should not need to use this directly, it is
+  # automatically included when you `include ModuleUtils` in a FFaker module.
+  module RandomUtils
+    # Returns a randon number from the internal Random Number Generator. Can be
+    # used in place of `rand` or `Kernal.rand`.
+    def rand(max = nil)
+      FFaker::Random.rand(max)
+    end
+
+    # Performs Array#sample on `list` using a the internal Random Number
+    # Generator so that the results are deterministic.
+    #
+    # * Returns one random item from `list`.
+    # * Pass `count: n` in options argument, where `n` is an integer, to
+    # return *n* items from `list`
+    def fetch_sample(list, options = {})
+      if (count = options.delete(:count))
+        list.sample(count, random: FFaker::Random)
+      elsif list.is_a?(Range)
+        FFaker::Random.rand(list)
+      else
+        list.sample(random: FFaker::Random)
+      end
+    end
+
+    # Performs same action as as `Array#suffle` (returns a randomly-reordered
+    # copy of `list`) except that it uses the internal Random Number Generator
+    # so that the results are deterministic.
+    def shuffle(list)
+      list.shuffle(random: FFaker::Random)
+    end
+  end
+end

data/ffaker-2.25.0/lib/ffaker/utils/unique_utils.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module FFaker
+  class UniqueUtils
+    RetryLimitExceeded = Class.new(StandardError)
+
+    class << self
+      def add_instance(generator, max_retries)
+        instances[generator] ||= FFaker::UniqueUtils.new(generator, max_retries)
+      end
+
+      def instances
+        Thread.current[:ffaker_unique_utils] ||= {}
+      end
+
+      def clear
+        instances.each_value(&:clear)
+        instances.clear
+      end
+    end
+
+    def initialize(generator, max_retries)
+      @generator = generator
+      @max_retries = max_retries
+    end
+
+    def clear
+      previous_results.clear
+    end
+
+    private
+
+    def method_missing(name, *args, **kwargs)
+      @max_retries.times do
+        result = @generator.public_send(name, *args, **kwargs)
+
+        next if previous_results[[name, args, kwargs]].include?(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
+  end
+end

data/ffaker-2.25.0/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/ffaker-2.25.0/lib/ffaker/vehicle.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+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
+
+    DRIVETRAINS = %w[4WD 4X4 AWD FWD RWD].freeze
+    YEARS = Array('1900'..(::Time.now.year + 1).to_s).freeze
+    TRANSMISSIONS_ABBR = %w[AT MT AM CVT].freeze
+    CYLINDERS = %w[2 5 6 8].freeze
+
+    def base_color
+      FFaker::Color.name
+    end
+
+    def drivetrain
+      fetch_sample(DRIVETRAINS)
+    end
+
+    def make
+      fetch_sample(MAKES_LIST)
+    end
+
+    def manufacturer_color(count = 2)
+      # Take two prefixes because it's more fun than one
+      (fetch_sample(COLOR_PREFIXES, count: count) + [base_color]).join(' ')
+    end
+    alias mfg_color manufacturer_color
+
+    def model
+      fetch_sample(MODELS_LIST)
+    end
+
+    def trim
+      fetch_sample(TRIMS_LIST)
+    end
+
+    def vin
+      VIN.vin
+    end
+
+    def year
+      fetch_sample(YEARS)
+    end
+
+    def transmission
+      fetch_sample(TRANSMISSIONS_LIST)
+    end
+
+    def transmission_abbr
+      fetch_sample(TRANSMISSIONS_ABBR)
+    end
+
+    def engine_cylinders
+      fetch_sample(CYLINDERS)
+    end
+
+    def engine_displacement
+      fetch_sample(DISPLACEMENTS_LIST)
+    end
+
+    def fuel_type
+      fetch_sample(FUEL_TYPES_LIST)
+    end
+
+    def interior_upholstery
+      fetch_sample(UPHOLSTERY_LIST)
+    end
+  end
+end

data/ffaker-2.25.0/lib/ffaker/venue.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module FFaker
+  module Venue
+    extend ModuleUtils
+    extend self
+
+    def name
+      fetch_sample(VENUE_LIST)
+    end
+  end
+end

data/ffaker-2.25.0/lib/ffaker/version.rb

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

data/ffaker-2.25.0/lib/ffaker/youtube.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module FFaker
+  module Youtube
+    extend ModuleUtils
+    extend self
+
+    def url
+      "www.youtube.com/watch?v=#{video_id}"
+    end
+
+    def share_url
+      "youtu.be/#{video_id}"
+    end
+
+    def embed_url
+      "www.youtube.com/embed/#{video_id}"
+    end
+
+    def video_id
+      fetch_sample(VIDEO_IDS)
+    end
+  end
+end

data/ffaker-2.25.0/lib/ffaker.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require_relative 'ffaker/version'
+require 'pathname'
+
+module FFaker
+  require_relative 'ffaker/utils/array_utils'
+  require_relative 'ffaker/utils/module_utils'
+
+  extend ModuleUtils
+
+  BASE_LIB_PATH = File.expand_path(__dir__)
+
+  LETTERS = Array('a'..'z').freeze
+
+  HEX = %w[0 1 2 3 4 5 6 7 8 9 A B C D E F].freeze
+
+  def self.hexify(*masks)
+    fetch_sample(masks.flatten).gsub('#') { fetch_sample(HEX) }
+  end
+
+  def self.numerify(*masks)
+    fetch_sample(masks.flatten).gsub('#') { rand(0..9).to_s }
+  end
+
+  def self.letterify(*masks)
+    fetch_sample(masks.flatten).gsub('?') { fetch_sample(LETTERS) }
+  end
+
+  def self.bothify(masks)
+    letterify(numerify(masks))
+  end
+
+  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.
+  module Random
+    # Returns the current RNG seed.
+    def self.seed
+      @seed ||= ::Random.new_seed
+    end
+
+    # Sets the RNG seed and creates a new internal RNG.
+    def self.seed=(new_seed)
+      @seed = new_seed
+      reset!
+      new_seed
+    end
+
+    # Reset the RNG back to its initial state.
+    def self.reset!
+      @rng = new_rng
+    end
+
+    # Returns a random number using an RNG with a known seed.
+    def self.rand(max = nil)
+      return rng.rand(max) if max
+
+      rng.rand
+    end
+
+    # Returns the current Random object.
+    def self.rng
+      @rng ||= new_rng
+    end
+
+    # Returns a new Random object instantiated with #seed.
+    def self.new_rng
+      ::Random.new(seed)
+    end
+  end
+end