faker 2.20.0 → 3.2.1

data/lib/faker/tv_shows/spongebob.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Faker
+  class TvShows
+    class Spongebob < Base
+      flexible :spongebob
+
+      class << self
+        ##
+        # Produces a character from Spongebob.
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::TvShows::Spongebob.character #=> "Patrick"
+        #
+        # @faker.version next
+        def character
+          fetch('spongebob.characters')
+        end
+
+        ##
+        # Produces a quote from Spongebob.
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::TvShows::Spongebob.quote #=> "I'm ready! I'm ready!"
+        #
+        # @faker.version next
+        def quote
+          fetch('spongebob.quotes')
+        end
+
+        ##
+        # Produces an episode from Spongebob.
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::TvShows::Spongebob.episode #=> "Reef Blower"
+        #
+        # @faker.version next
+        def episode
+          fetch('spongebob.episodes')
+        end
+      end
+    end
+  end
+end

data/lib/faker/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Faker # :nodoc:
-  VERSION = '2.20.0'
+  VERSION = '3.2.1'
 end

data/lib/faker.rb

@@ -4,32 +4,37 @@ mydir = __dir__
 
 require 'psych'
 require 'i18n'
-require 'set' # Fixes a bug in i18n 0.6.11
 
 Dir.glob(File.join(mydir, 'helpers', '*.rb')).sort.each { |file| require file }
 
 I18n.load_path += Dir[File.join(mydir, 'locales', '**/*.yml')]
-I18n.reload! if I18n.backend.initialized?
 
 module Faker
   module Config
-    @locale = nil
-    @random = nil
+    @default_locale = nil
 
     class << self
-      attr_writer :locale, :random
+      attr_writer :default_locale
+
+      def locale=(new_locale)
+        Thread.current[:faker_config_locale] = new_locale
+      end
 
       def locale
         # Because I18n.locale defaults to :en, if we don't have :en in our available_locales, errors will happen
-        @locale || (I18n.available_locales.include?(I18n.locale) ? I18n.locale : I18n.available_locales.first)
+        Thread.current[:faker_config_locale] || @default_locale || (I18n.available_locales.include?(I18n.locale) ? I18n.locale : I18n.available_locales.first)
       end
 
       def own_locale
-        @locale
+        Thread.current[:faker_config_locale]
+      end
+
+      def random=(new_random)
+        Thread.current[:faker_config_random] = new_random
       end
 
       def random
-        @random || Random.new
+        Thread.current[:faker_config_random] || Random
       end
     end
   end
@@ -41,23 +46,29 @@ module Faker
     Letters = ULetters + LLetters
 
     class << self
+      attr_reader :flexible_key
+
       NOT_GIVEN = Object.new
 
       ## by default numerify results do not start with a zero
       def numerify(number_string, leading_zero: false)
-        return number_string.gsub(/#/) { rand(10).to_s } if leading_zero
+        return number_string.gsub('#') { rand(10).to_s } if leading_zero
 
-        number_string.sub(/#/) { rand(1..9).to_s }.gsub(/#/) { rand(10).to_s }
+        number_string.sub('#') { rand(1..9).to_s }.gsub('#') { rand(10).to_s }
       end
 
       def letterify(letter_string)
-        letter_string.gsub(/\?/) { sample(ULetters) }
+        letter_string.gsub('?') { sample(ULetters) }
       end
 
       def bothify(string)
         letterify(numerify(string))
       end
 
+      def generate(as_type, &block)
+        PositionalGenerator.new(as_type, &block).generate
+      end
+
       # Given a regular expression, attempt to generate a string
       # that would match it.  This is a rather simple implementation,
       # so don't be shocked if it blows up on you in a spectacular fashion.
@@ -81,13 +92,13 @@ module Faker
         reg = reg.source if reg.respond_to?(:source) # Handle either a Regexp or a String that looks like a Regexp
         reg
           .gsub(%r{^/?\^?}, '').gsub(%r{\$?/?$}, '') # Ditch the anchors
-          .gsub(/\{(\d+)\}/, '{\1,\1}').gsub(/\?/, '{0,1}') # All {2} become {2,2} and ? become {0,1}
+          .gsub(/\{(\d+)\}/, '{\1,\1}').gsub('?', '{0,1}') # All {2} become {2,2} and ? become {0,1}
           .gsub(/(\[[^\]]+\])\{(\d+),(\d+)\}/) { |_match| Regexp.last_match(1) * sample(Array(Range.new(Regexp.last_match(2).to_i, Regexp.last_match(3).to_i))) }                # [12]{1,2} becomes [12] or [12][12]
           .gsub(/(\([^)]+\))\{(\d+),(\d+)\}/) { |_match| Regexp.last_match(1) * sample(Array(Range.new(Regexp.last_match(2).to_i, Regexp.last_match(3).to_i))) }                 # (12|34){1,2} becomes (12|34) or (12|34)(12|34)
           .gsub(/(\\?.)\{(\d+),(\d+)\}/) { |_match| Regexp.last_match(1) * sample(Array(Range.new(Regexp.last_match(2).to_i, Regexp.last_match(3).to_i))) }                      # A{1,2} becomes A or AA or \d{3} becomes \d\d\d
           .gsub(/\((.*?)\)/) { |match| sample(match.gsub(/[()]/, '').split('|')) } # (this|that) becomes 'this' or 'that'
           .gsub(/\[([^\]]+)\]/) { |match| match.gsub(/(\w-\w)/) { |range| sample(Array(Range.new(*range.split('-')))) } } # All A-Z inside of [] become C (or X, or whatever)
-          .gsub(/\[([^\]]+)\]/) { |_match| sample(Regexp.last_match(1).split('')) } # All [ABC] become B (or A or C)
+          .gsub(/\[([^\]]+)\]/) { |_match| sample(Regexp.last_match(1).chars) } # All [ABC] become B (or A or C)
           .gsub('\d') { |_match| sample(Numbers) }
           .gsub('\w') { |_match| sample(Letters) }
       end
@@ -185,9 +196,9 @@ module Faker
       #     girls_name: ["Alice", "Cheryl", "Tatiana"]
       # Then you can call Faker::Name.girls_name and it will act like #first_name
       def method_missing(mth, *args, &block)
-        super unless @flexible_key
+        super unless flexible_key
 
-        if (translation = translate("faker.#{@flexible_key}.#{mth}"))
+        if (translation = translate("faker.#{flexible_key}.#{mth}"))
           sample(translation)
         else
           super
@@ -255,58 +266,6 @@ module Faker
       ensure
         I18n.enforce_available_locales = old_enforce_available_locales
       end
-
-      private
-
-      def warn_for_deprecated_arguments
-        keywords = []
-        yield(keywords)
-
-        return if keywords.empty?
-
-        method_name = caller.first.match(/`(?<method_name>.*)'/)[:method_name]
-
-        keywords.each.with_index(1) do |keyword, index|
-          i = case index
-              when 1 then '1st'
-              when 2 then '2nd'
-              when 3 then '3rd'
-              else "#{index}th"
-              end
-
-          warn_with_uplevel(<<~MSG, uplevel: 5)
-            Passing `#{keyword}` with the #{i} argument of `#{method_name}` is deprecated. Use keyword argument like `#{method_name}(#{keyword}: ...)` instead.
-          MSG
-        end
-
-        warn(<<~MSG)
-
-          To automatically update from positional arguments to keyword arguments,
-          install rubocop-faker and run:
-
-          rubocop \\
-            --require rubocop-faker \\
-            --only Faker/DeprecatedArguments \\
-            --auto-correct
-
-        MSG
-      end
-
-      # Workaround for emulating `warn '...', uplevel: 1` in Ruby 2.4 or lower.
-      def warn_with_uplevel(message, uplevel: 1)
-        at = parse_caller(caller[uplevel]).join(':')
-        warn "#{at}: #{message}"
-      end
-
-      def parse_caller(at)
-        # rubocop:disable Style/GuardClause
-        if /^(.+?):(\d+)(?::in `.*')?/ =~ at
-          file = Regexp.last_match(1)
-          line = Regexp.last_match(2).to_i
-          [file, line]
-        end
-        # rubocop:enable Style/GuardClause
-      end
     end
   end
 end

data/lib/helpers/base58.rb

@@ -7,7 +7,7 @@ module Faker
       base = alphabet.size
 
       lv = 0
-      str.split('').reverse.each_with_index { |v, i| lv += v.unpack1('C') * 256**i }
+      str.chars.reverse.each_with_index { |v, i| lv += v.unpack1('C') * 256**i }
 
       ret = +''
       while lv.positive?

data/lib/helpers/positional_generator.rb

@@ -0,0 +1,480 @@
+# frozen_string_literal: true
+
+##
+# A high level way to generate a list of generated values that fit a specific
+# format, such as an ID, postal code, or phone number.
+#
+# It provides generators for random digits and letters, hardcoded literal
+# strings, computed values based on previously-generated values, union (one-of)
+# selectors, and grouped generators.
+#
+# The generation allows for dependencies on previously generated values -- most
+# useful for computations -- and this object knows how to build that dependency
+# graph.
+#
+# See {PositionalGenerator::Builder} for more.
+class PositionalGenerator
+  ##
+  # @param as_type [Symbol] +:string+ to generate a String
+  # @param block [Method] a function that interacts with the {Builder}
+  def initialize(as_type, &block)
+    @block = block
+    @generator_builder = Builder.new(as_type)
+  end
+
+  ##
+  # @return [String] if +as_type+ is +:string+
+  def generate
+    @block.call(@generator_builder)
+    @generator_builder.build
+  end
+
+  Component = Struct.new(:position, :name, :deps, :generator)
+
+  class Builder
+    attr_reader :as_type
+
+    def initialize(as_type)
+      @components = []
+      @as_type = as_type
+    end
+
+    ##
+    # Generate a value in the range of 0..9.
+    #
+    # @param name [Symbol] the name for this node in the group
+    # @param length [Integer] how many digits to generate
+    # @param ranges [Array<Range, Array, Set>] an array of limitations on the
+    #   generation. Elements can be a Range to select from within that range,
+    #   or an Array or Set to select an element from within the list.
+    # @return [void]
+    #
+    # @example a digit
+    #   int
+    #
+    # @example five digits named :a
+    #   int(name: :a, length: 5)
+    #
+    # @example digits of any length between 4 to 10
+    #   int(ranges: [1_000 .. 9_999_999_999)
+    def int(name: nil, length: 1, ranges: nil)
+      @components << Component.new(@components.count, name, [], Int.new(length, ranges))
+    end
+
+    ##
+    # Generate a value in the range of 'a'..'Z'.
+    #
+    # @param name [Symbol] the name for this node in the group
+    # @param length [Integer, Range] how many letters to generate
+    # @param ranges [Array<Range, Array, Set>] an array of limitations on the
+    #   generation. Elements can be a Range to select from within that range,
+    #   or an Array or Set to select an element from within the list.
+    # @return [void]
+    #
+    # @example Generate a letter
+    #   letter
+    #
+    # @example Generate five uppercase letters named :b
+    #   letter(name: :b, length: 5, ranges: ['A'..'Z'])
+    #
+    # @example Generate three-letter strings from within specific values
+    #   letter(ranges: ['700'..'799', '7A0'..'7F9'])
+    def letter(name: nil, length: 1, ranges: ['a'..'z', 'A'..'Z'])
+      @components << Component.new(@components.count, name, [], Letter.new(length, ranges))
+    end
+
+    ##
+    # Generate a literal String
+    #
+    # @param value [String]
+    # @param name [Symbol] the name for this node in the group
+    # @return [void]
+    # @example
+    #   lit("-")
+    def lit(value, name: nil)
+      @components << Component.new(@components.count, name, [], Literal.new(value))
+    end
+
+    ##
+    # Fill the position with an arbitrary value.
+    #
+    # @param name [Symbol] the name for this node in the group
+    # @param deps [Array<Symbol>] the name of other fields that this one depends on
+    # @param block [Method] the block that yields the arbitrary value. Its
+    #   arguments are the deps.
+    # @return [void]
+    #
+    # @example Today's date
+    #   computed do
+    #     Date.today
+    #   end
+    #
+    # @example A check digit
+    #   int(name: :a, length: 5)
+    #   computed(deps: [:a]) do |a|
+    #     a.to_s.bytes.sum % 10
+    #   end
+    def computed(name: nil, deps: [], &block)
+      @components << Component.new(@components.count, name, deps, Computed.new(block))
+    end
+
+    ##
+    # Fill the position with one of the results from the given generators.
+    #
+    # @param name [Symbol] the name for this node in the group
+    # @param block [Method] subgenerator block
+    # @return [void]
+    #
+    # @example Either five digits, or two letters
+    #   oneof do |or_else|
+    #     or_else.int(length: 5)
+    #     or_else.letter(length: 2)
+    #   end
+    #
+    # @example Either one letter; or a slash, five digits, then a slash.
+    #   oneof do |or_else|
+    #     or_else.letter
+    #     or_else.group do |g_|
+    #       g_.lit("/")
+    #       g_.digit(length: 5)
+    #       g_.lit("/")
+    #     end
+    #   end
+    def oneof(name: nil, &block)
+      @components << Component.new(@components.count, name, [], Oneof.new(self, block))
+    end
+
+    ##
+    # A group of generators. Useful for {#oneof}.
+    #
+    # @param name [Symbol] the name for this node in the group
+    # @param block [Method] a subgenerator block
+    # @return [void]
+    def group(name: nil, &block)
+      @components << Component.new(@components.count, name, [], Group.new(@as_type, block))
+    end
+
+    ##
+    # Generate the value.
+    #
+    # @return [String] if +as_type+ is +:string+
+    def build
+      graph = build_graph
+      stack = build_stack(graph)
+      values = generate_values(stack)
+      convert(values)
+    end
+
+    private
+
+    ##
+    # Turn the components into a graph following dependencies.
+    #
+    # @return [Array<(Integer, Integer)>]
+    #
+    # Components can have dependencies. Here's one where a computation (b)
+    # depends on a value generated after it (c):
+    #
+    #     @components = [
+    #       Int.new(0, :a, 1, nil),
+    #       Computed.new(1, :b, [:c]) { |c| c + 1 },
+    #       Int.new(2, :c, 1, nil),
+    #     ]
+    #
+    # We can think of a graph like so:
+    #
+    #      (a)  (c)
+    #       |    |
+    #       |   (b)
+    #       \   /
+    #        end
+    #
+    # Or in Mermaid:
+    #
+    # ```mermaid
+    # stateDiagram-v2
+    #     a --> [*]
+    #     c --> b
+    #     b --> [*]
+    # ```
+    #
+    # This method builds that graph, using their positional locations as the
+    # ID. The end state is represented as +nil+. So continuing the example
+    # above, it will give this output:
+    #
+    #     [
+    #       [0, nil],
+    #       [2, 1],
+    #       [1, nil],
+    #     ]
+    #
+    # Later we can look up the appropriate component by indexing into the
+    # +@components+ array.
+    def build_graph
+      graph = []
+
+      # rubocop:disable Style/CombinableLoops
+      @components.each do |component|
+        component.deps.each do |dep|
+          dep_component = @components.detect { |c| c.name == dep }
+          raise if dep_component.nil?
+
+          graph.push([dep_component.position, component.position])
+        end
+      end
+
+      @components.each do |component|
+        graph.push([component.position, nil]) if graph.none? { |(from, _to)| from == component.position }
+      end
+      # rubocop:enable Style/CombinableLoops
+
+      graph
+    end
+
+    ##
+    # Produce a stack of components to evaluate in sequence.
+    #
+    # @param graph [Array<(Integer, Integer)>]
+    # @return [Array<Array<Int>>]
+    #
+    # Now that we have a graph, we know enough to determine how to traverse the
+    # generators such that all dependencies are met.
+    #
+    # The initial stack is an array of all the free traversals to the goal
+    # (where the +to+ is +nil+).
+    #
+    # Loop over the top of the stack:
+    # - The next array is all the nodes that lead into the nodes atop the
+    #    stack.
+    # - If the next array has values, push that onto the top of the stack.
+    # - If the next array is empty, we are done.
+    #
+    # For example, given the graph:
+    #
+    #     [
+    #       [0, nil],
+    #       [2, 1],
+    #       [1, nil],
+    #     ]
+    #
+    # The initial stack is:
+    #
+    #     [
+    #       [0, 1]
+    #     ]
+    #
+    # We loop over the top of the stack, +[0, 1]+, and find all the nodes of
+    # the graph that lead there. Nothing leads to +0+, and +2+ leads to +1+.
+    #
+    # Therefore, push +[2]+ to the top of the stack.
+    #
+    # Repeat for +[2]+. Nothing leads to +2+, so our new goal is +[]+. This is
+    # empty, so don't push it onto the stack. We are done.
+    #
+    # The final stack is:
+    #
+    #     [
+    #       [0, 1],
+    #       [2]
+    #     ]
+    def build_stack(graph)
+      require 'set'
+
+      terminals = graph.filter_map { |(from, to)| to.nil? && from }
+      stack = [terminals]
+      seen = Set.new(terminals)
+      deps = []
+
+      loop do
+        stack[-1].each do |e|
+          deps = graph.select { |(from, to)| to == e && !seen.include?(from) }.map do |from, _to|
+            seen << from
+            from
+          end
+          stack << deps if deps.any?
+        end
+
+        break if deps.empty?
+      end
+
+      stack
+    end
+
+    ##
+    # Turn a stack into a list of generated values.
+    #
+    # @param stack [Array<Array<Int>>]
+    # @return [Array<Object>] values sorted by desired order
+    #
+    # We start with a stack of components we need evaluated. We have been
+    # tracking these components by position, so first we need to look up the
+    # component in our list.
+    #
+    # From there we can get a list of all the dependencies for the component.
+    # These have already been evaluated, since +stack+ is sorted, so we fetch
+    # them.
+    #
+    # Since the stack was sorted by computation order, we must re-sort them
+    # into positional order at the end.
+    def generate_values(stack)
+      result = []
+
+      while (top = stack.pop)
+        top.each do |component_id|
+          component = @components[component_id]
+          raise if component.nil?
+
+          values = result.filter_map do |(_id, name, value)|
+            value if component.deps.include?(name)
+          end
+
+          result << [component.position, component.name, component.generator.generate(values)]
+        end
+      end
+
+      result.sort_by do |component_position, _, _|
+        component_position
+      end
+    end
+
+    ##
+    # @param values [Array<Object>]
+    # @return [String] if +@as_type+ is +:string+
+    # @raise [ArgumentError] if +@as_type+ is unsupported
+    def convert(values)
+      case @as_type
+      when :string
+        values.inject('') do |acc, (_, _, v)|
+          "#{acc}#{v}"
+        end
+      else
+        raise ArgumentError, "unknown return type: #{@as_type}"
+      end
+    end
+
+    class Group
+      def initialize(as_type, block)
+        @as_type = as_type
+        @block = block
+      end
+
+      def generate(_)
+        builder = Builder.new(@as_type)
+        @block.call(builder)
+        builder.build
+      end
+    end
+
+    class Oneof
+      def initialize(builder, block)
+        @block = block
+        @builder = builder
+      end
+
+      def generate(...)
+        subgens = OneofSelector.new(@builder)
+        @block.call(subgens)
+        subgens.sample
+        subgens.generate(...)
+      end
+
+      class OneofSelector
+        def initialize(builder)
+          @subgens = []
+          @builder = Builder.new(builder.as_type)
+        end
+
+        def method_missing(meth, *args, **kwargs, &block)
+          @subgens << [meth, args, kwargs, block]
+        end
+
+        def respond_to_missing?(method_name, include_private = false)
+          @builder.respond_to?(method_name, include_private)
+        end
+
+        def sample
+          (meth, args, kwargs, block) = Faker::Base.sample(@subgens)
+          @builder.send(meth, *args, **kwargs, &block)
+        end
+
+        def generate(...)
+          @builder.build
+        end
+      end
+    end
+
+    class Int
+      def initialize(length, ranges)
+        # Internally we store only an Enumerable of Range values. So if we are
+        # not given any Ranges but are given a length, we need to convert the
+        # length to a Range.
+        #
+        # If the length is `5`, that means we should compute the Range `10000..99999`.
+        # We can compute the lower end with a simple exponent: 10^4 = 10000.
+        # The upper end is one less than an exponent: 10^5 - 1 = 99999.
+        if ranges.nil?
+          lower = 10**(length - 1)
+          upper = (10**length) - 1
+          ranges = [lower..upper]
+        end
+
+        @ranges = ranges
+      end
+
+      def generate(_)
+        Faker::Base.rand(@ranges.sample(random: Faker::Config.random))
+      end
+    end
+
+    class Letter
+      def initialize(length, ranges)
+        @length = length
+        @ranges = ranges
+      end
+
+      def generate(_)
+        @length.times.inject('') do |acc, _index|
+          generated_character = char
+          "#{acc}#{generated_character}"
+        end
+      end
+
+      private
+
+      def char
+        if @ranges
+          case s = @ranges.sample(random: Faker::Config.random)
+          when Range
+            s.to_a.sample(random: Faker::Config.random)
+          when Array, Set
+            s.sample(random: Faker::Config.random)
+          else
+            raise ArgumentError, "unsupported range type: #{s.inspect}"
+          end
+        else
+          Faker::Base.sample(Faker::Base::Letters)
+        end
+      end
+    end
+
+    class Literal
+      def initialize(value)
+        @value = value
+      end
+
+      def generate(_)
+        @value
+      end
+    end
+
+    class Computed
+      def initialize(block)
+        @block = block
+      end
+
+      def generate(args)
+        @block.call(*args)
+      end
+    end
+  end
+end