giga-max-mod 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