faker 3.2.0 → 3.2.3

data/lib/faker/default/html.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+module Faker
+  class HTML < Base
+    class << self
+      ##
+      # Produces a random HTML header format.
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::HTML.heading #=> "<h5>Autem</h5>"
+      #
+      # @faker.version 3.2.1
+      def heading
+        level = rand(1..6)
+        "<h#{level}>#{Lorem.word.capitalize}</h#{level}>"
+      end
+
+      ##
+      # Produces a random HTML paragraph format.
+      #
+      # @param sentence_count [Integer] The number of sentences in the paragraph.
+      # @param supplemental [Boolean] Include supplemental text.
+      # @param random_sentences_to_add [Integer] The number of random sentences to add to the paragraph.
+      # @param exclude_words [Array<String>] Words to exclude from the generated paragraph.
+      # @return [String]
+      #
+      # @example
+      #   Faker::HTML.paragraph #=> "<p>Incidunt atque quis</p>"
+      #
+      # @faker.version 3.2.1
+      def paragraph(sentence_count: 3, supplemental: false, random_sentences_to_add: 0, exclude_words: nil)
+        "<p>#{Faker::Lorem.paragraph(sentence_count: sentence_count, supplemental: supplemental, random_sentences_to_add: random_sentences_to_add, exclude_words: exclude_words)}</p>"
+      end
+
+      ##
+      # Produces a random emphasis formatting on a random word in two HTML paragraphs.
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::HTML.emphasis #=> "<em>repellat id impedit</em>"
+      #
+      # @faker.version 3.2.1
+      def emphasis
+        "<em>#{Faker::Lorem.paragraph(sentence_count: 1)}</em>"
+      end
+
+      ##
+      # Produces a random ordered list in HTML format, with at least one element.
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::HTML.ordered_list #=> "<ol>\n<li>Qui reiciendis non consequatur atque.</li>\n<li>Quo doloremque veritatis tempora aut.</li>\n<li>Aspernatur.</li>\n<li>Ea ab.</li>\n<li>Qui.</li>\n<li>Sit pariatur nemo eveniet.</li>\n<li>Molestiae aut.</li>\n<li>Nihil molestias iure placeat.</li>\n<li>Dolore autem quisquam.</li>\n</ol>"
+      #
+      # @faker.version 3.2.1
+      def ordered_list
+        number = rand(1..10)
+
+        items = []
+        number.times do
+          items << "<li>#{Faker::Lorem.sentence(word_count: 1)}</li>"
+        end
+
+        "<ol>\n#{items.join("\n")}\n</ol>"
+      end
+
+      ##
+      # Produces a random unordered list of items between 1 and 10 randomly in HTML format.
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::HTML.unordered_list #=> "<ul>\n<li>Voluptatum aliquid tempora molestiae facilis non sed.</li>\n<li>Nostrum omnis iste impedit voluptatum dolor.</li>\n<li>Esse quidem et facere.</li>\n</ul>"
+      #
+      # @faker.version 3.2.1
+      def unordered_list
+        number = rand(1..10)
+
+        items = []
+        number.times do
+          items << "<li>#{Faker::Lorem.sentence(word_count: 1)}</li>"
+        end
+
+        "<ul>\n#{items.join("\n")}\n</ul>"
+      end
+
+      ##
+      # Produces a random code block formatted in HTML.
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::HTML.code #=> "<code>Eos quasi qui.</code>"
+      #
+      # @faker.version 3.2.1
+      def code
+        "<code>#{Lorem.sentence(word_count: 1)}</code>"
+      end
+
+      ##
+      # Produces a random HTML table.
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::HTML.table #=> "<table>\n<thead>\n<th>ad</th>\n<th>similique</th>\n<th>voluptatem</th>\n</thead>\n<tbody>\n<td>corrupti</td>\n<td>est</td>\n<td>rerum</td>\n<td>molestiae</td>\n<td>quidem</td>\n<td>et</td>\n<td>in</td>\n<td>tempora</td>\n<td>at</td>\n<\tbody>\n<tfoot>\n<td>voluptatem</td>\n<td>debitis</td>\n<td>rem</td>\n</tfoot>\n</table>"
+      #
+      # @faker.version 3.2.1
+      def table
+        header_row = generate_table_row('th', 3)
+        footer_row = generate_table_row('td', 3)
+
+        body_rows = []
+        3.times do
+          row = generate_table_row('td', 3)
+          body_rows << row
+        end
+
+        thead = "<thead>\n#{header_row}</thead>"
+        tbody = "<tbody>\n#{body_rows.join("\n")}</tbody>"
+        tfoot = "<tfoot>\n#{footer_row}</tfoot>"
+
+        "<table>\n#{thead}\n#{tbody}\n#{tfoot}\n</table>"
+      end
+
+      ##
+      # Generates a random <script> tag with the `src` attribute set to a random URL.
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::HTML.script #=> "<script src=\"http://gulgowski.name/jordan.weimann.js\"></script>"
+      #
+      # @faker.version 3.2.1
+      def script
+        "<script src=\"#{Faker::Internet.url}.js\"></script>"
+      end
+
+      ##
+      # Generates a random <link> tag with the `rel` attribute set to "stylesheet" and the `href` attribute set to a random URL.
+      #
+      # @param rel [String] The rel of the link tag.
+      # @return [String]
+      #
+      # @example
+      #   Faker::HTML.link #=> "<link rel=\"stylesheet\" href=\"http://fay.io/darryl.barrows.css\">"
+      #
+      # @faker.version 3.2.1
+      def link(rel: 'stylesheet')
+        "<link rel=\"#{rel}\" href=\"#{Faker::Internet.url}.css\">"
+      end
+
+      ##
+      # Generates HTML content with customizable attributes for any HTML tag.
+      #
+      # @param tag [String] The HTML tag to generate.
+      # @param content [String] The Content of the HTML tag.
+      # @param attributes [Hash] The attributes to include in the tag.
+      # @return [String]
+      #
+      # @example
+      #   Faker::HTML.element(tag: 'div', content: "This is a div with XSS attributes.", attributes: {class: 'xss', onclick: "alert('XSS')"}) #=> "<div class=\"xss\" onclick=\"alert('XSS')\">This is a div with XSS attributes.</div>"
+      #
+      # @faker.version 3.2.1
+      def element(tag: 'div', content: Lorem.sentence(word_count: 3), attributes: { class: Lorem.word, onclick: "#{Lorem.word}()" })
+        attribute_string = attributes.map { |key, value| "#{key}=\"#{value}\"" }.join(' ')
+        "<#{tag} #{attribute_string}>#{content}</#{tag}>"
+      end
+
+      ##
+      # Produces a random method from the methods above, excluding the methods listed in the arguments.
+      #
+      # @overload random(methods)
+      #   @param methods [Symbol] Specify which methods to exclude.
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::HTML.random #=> returns output from a single method outlined above
+      #   Faker::HTML.random(exclude: [:table]) #=> returns output from any single method outlined above except for "table"
+      #   Faker::HTML.random(exclude: [:ordered_list, :unordered_list]) #=> returns output from any single method outlined above except for either ordered_list and unordered_list
+      #
+      # @faker.version 3.2.1
+      def random(exclude: [])
+        method_list = available_methods
+        exclude.each { |ex| method_list.delete_if { |meth| meth == ex.to_sym } }
+        send(method_list[Faker::Config.random.rand(0..method_list.length - 1)])
+      end
+
+      ##
+      # Generates a random HTML content sandwich, starting with a header, followed by paragraphs, and random elements.
+      #
+      # @param sentences [Integer] The number of sentences in each paragraph.
+      # @param repeat [Integer] The number of times to repeat the pattern (header, paragraph, random).
+      # @return [String]
+      #
+      # @example
+      #   Faker::HTML.sandwich(sentences: 3, repeat: 2) #=> returns a sandwich of HTML content with 2 repetitions, each having a header, paragraph, and random element
+      #
+      # @faker.version 3.2.1
+      def sandwich(sentences: 3, repeat: 1)
+        text_block = []
+        text_block << heading
+        repeat.times do
+          text_block << paragraph(sentence_count: sentences)
+          text_block << random(exclude: %i[script link])
+        end
+        text_block.join("\n")
+      end
+
+      private
+
+      def available_methods
+        (HTML.public_methods(false) - Base.methods).sort
+      end
+
+      def generate_table_row(tag, cell_count)
+        row = "<tr>\n"
+        cell_count.times do
+          row += "<#{tag == 'th' ? 'th' : 'td'}>#{Lorem.word}</#{tag == 'th' ? 'th' : 'td'}>\n"
+        end
+        row += "</tr>\n"
+        row
+      end
+    end
+  end
+end

data/lib/faker/default/id_number.rb

@@ -46,9 +46,23 @@ module Faker
       end
 
       def ssn_valid
-        ssn = regexify(/[0-8]\d{2}-\d{2}-\d{4}/)
-        # We could still have all 0s in one segment or another
-        INVALID_SSN.any? { |regex| regex =~ ssn } ? ssn_valid : ssn
+        generate(:string) do |g|
+          g.computed(name: :first) do
+            range = [1..665, 667..899].sample(random: Faker::Config.random)
+            n = Faker::Base.rand(range)
+            format('%03d', n)
+          end
+          g.lit('-')
+          g.computed(name: :second) do
+            n = Faker::Base.rand(1..99)
+            format('%02d', n)
+          end
+          g.lit('-')
+          g.computed(name: :third) do
+            n = Faker::Base.rand(1..9999)
+            format('%04d', n)
+          end
+        end
       end
 
       ##

data/lib/faker/default/internet.rb

@@ -159,7 +159,8 @@ module Faker
       #
       # @faker.version 2.1.3
       def password(min_length: 8, max_length: 16, mix_case: true, special_characters: false)
-        raise ArgumentError, 'max_length must be more than min_length' if max_length < min_length
+        raise ArgumentError, 'min_length and max_length must be greater than or equal to one' if min_length < 1 || max_length < 1
+        raise ArgumentError, 'min_length must be smaller than or equal to max_length' unless min_length <= max_length
 
         character_types = []
         required_min_length = 0
@@ -182,27 +183,27 @@ module Faker
         character_bag = []
 
         # use lower_chars by default and add upper_chars if mix_case
-        lower_chars = ('a'..'z').to_a
-        password << lower_chars[rand(lower_chars.count - 1)]
+        lower_chars = self::LLetters
+        password << sample(lower_chars)
         character_bag += lower_chars
 
-        digits = ('1'..'9').to_a
-        password << digits[rand(digits.count - 1)]
+        digits = ('0'..'9').to_a
+        password << sample(digits)
         character_bag += digits
 
-        if character_types.include?(:mix_case)
-          upper_chars = ('A'..'Z').to_a
-          password << upper_chars[rand(upper_chars.count - 1)]
+        if mix_case
+          upper_chars = self::ULetters
+          password << sample(upper_chars)
           character_bag += upper_chars
         end
 
-        if character_types.include?(:special_characters)
+        if special_characters
           special_chars = %w[! @ # $ % ^ & *]
-          password << special_chars[rand(special_chars.count - 1)]
+          password << sample(special_chars)
           character_bag += special_chars
         end
 
-        password << character_bag[rand(character_bag.count - 1)] while password.length < target_length
+        password << sample(character_bag) while password.length < target_length
 
         shuffle(password).join
       end

data/lib/faker/default/lorem.rb

@@ -10,10 +10,13 @@ module Faker
       #
       # @example
       #   Faker::Lorem.word   #=> "soluto"
+      #   Faker::Lorem.word(exclude_words: 'error') #=> "nisi"
+      #   Faker::Lorem.word(exclude_words: 'id, error') #=> "et"
+      #   Faker::Lorem.word(exclude_words: ['id', 'error']) #=> "consequatur"
       #
       # @faker.version 2.1.3
-      def word
-        sample(translate('faker.lorem.words'))
+      def word(exclude_words: nil)
+        words(number: 1, exclude_words: exclude_words).first
       end
 
       ##

data/lib/faker/default/types.rb

@@ -97,12 +97,13 @@ module Faker
       # @example
       #   Faker::Types.rb_array #=> ["a"]
       #   Faker::Types.rb_array(len: 4) #=> ["a", 1, 2, "bob"]
+      #   Faker::Types.rb_array(len: 2, type: -> { Faker::Types.rb_string }) #=> ["cat", "foo"]
       #
       # @faker.version 1.8.6
-      def rb_array(len: 1)
+      def rb_array(len: 1, type: -> { random_type })
         [].tap do |ar|
           len.times do
-            ar.push random_type
+            ar.push type.is_a?(Proc) ? type.call : type
           end
         end
       end

data/lib/faker/default/vehicle.rb

@@ -22,14 +22,25 @@ module Faker
       #
       # @faker.version 1.6.4
       def vin
-        front = 8.times.map { VIN_KEYSPACE.sample(random: Faker::Config.random) }.join
-        back = 8.times.map { VIN_KEYSPACE.sample(random: Faker::Config.random) }.join
-        checksum = "#{front}A#{back}".chars.each_with_index.map do |char, i|
-          value = (char =~ /\A\d\z/ ? char.to_i : VIN_TRANSLITERATION[char.to_sym])
-          value * VIN_WEIGHT[i]
-        end.inject(:+) % 11
-        checksum = 'X' if checksum == 10
-        "#{front}#{checksum}#{back}"
+        generate(:string) do |g|
+          g.letter(name: :wmi, ranges: ['100'..'199', '400'..'499', '500'..'599', '700'..'799', '7A0'..'7F9'])
+          g.letter(name: :vds, length: 5, ranges: [VIN_KEYSPACE])
+          g.computed(name: :checksum, deps: %i[wmi vds model_year plant_code vis]) do |wmi, vds, model_year, plant_code, vis|
+            checksum = "#{wmi}#{vds}0#{model_year}#{plant_code}#{vis}".chars.each_with_index.map do |char, i|
+              value = (char =~ /\A\d\z/ ? char.to_i : VIN_TRANSLITERATION[char.to_sym])
+              value * VIN_WEIGHT[i]
+            end.inject(:+) % 11
+
+            if checksum == 10
+              'X'
+            else
+              checksum
+            end
+          end
+          g.letter(name: :model_year, length: 1, ranges: [VIN_KEYSPACE - %w[U Z 0]])
+          g.letter(name: :plant_code, length: 1, ranges: [VIN_KEYSPACE])
+          g.int(name: :vis, length: 6)
+        end
       end
 
       # Produces a random vehicle manufacturer.

data/lib/faker/games/final_fantasy_xiv.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Faker
+  class Games
+    class FinalFantasyXIV < Base
+      class << self
+        ##
+        # Produces the name of a character from FFXIV.
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::Games::FinalFantasyXIV.character #=> "Y'shtola Rhul"
+        #
+        # @faker.version next
+        def character
+          fetch('games.final_fantasy_xiv.characters')
+        end
+
+        ##
+        # Produces a job name from Final Fantasy XIV. Either a battle or non-battle playable job.
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::Games::FinalFantasyXIV.job #=> "Paladin"
+        #
+        # @faker.version next
+        def job
+          fetch('games.final_fantasy_xiv.jobs')
+        end
+
+        # Produces the name of a playable race from Final Fantasy XIV.
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::Games::FinalFantasyXIV.race #=> "Miqo'te"
+        #
+        # @faker.version next
+        def race
+          fetch('games.final_fantasy_xiv.races')
+        end
+
+        ##
+        # Produces a data center from Final Fantasy XIV.
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::Games::FinalFantasyXIV.data_center #=> "Aether"
+        #
+        # @faker.version next
+        def data_center
+          fetch('games.final_fantasy_xiv.data_centers')
+        end
+
+        ##
+        # Produces a geographical zone from Final Fantasy XIV.
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::Games::FinalFantasyXIV.zone #=> "Eastern La Noscea"
+        #
+        # @faker.version next
+        def zone
+          fetch('games.final_fantasy_xiv.zones')
+        end
+      end
+    end
+  end
+end

data/lib/faker/travel/airport.rb

@@ -11,7 +11,7 @@ module Faker
         #
         # @param region [String] airport region, currently available -> united_states or european_union
         #
-        # @retrun [String]
+        # @return [String]
         #
         # @example
         # Faker::Travel::Airport.name(size: 'large', region: 'united_states') => "Los Angeles International Airport"
@@ -28,7 +28,7 @@ module Faker
         #
         # @param region [String] airport region, currently available -> united_states or european_union
         #
-        # @retrun [String]
+        # @return [String]
         #
         # @example
         # Faker::Travel::Airport.iata(size: 'large', region: 'united_states') => "LAX"

data/lib/faker/travel/train_station.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Faker
+  class Travel
+    class TrainStation < Base
+      class << self
+        ##
+        # Produces random Train Station by name and takes optional arguments for region and type
+        #
+        # @param region [String] Train station region: germany, spain, united_kingdom, united_states
+        #
+        # @param type [String] Train station type: metro, railway
+        #
+        # @return [String]
+        #
+        # @examples
+        # Faker::Travel::TrainStation.name(region: 'united_kingdom', type: 'metro') => "Brockley"
+        # Faker::Travel::TrainStation.name(type: 'railway') => "Düsseldorf Hauptbahnhof"
+        # Faker::Travel::TrainStation.name(region: 'spain') => "Santa Eulàlia"
+        #
+        # @faker.version next
+        def name(region: nil, type: nil)
+          region, type = fill_missing_inputs_with_samples(region, type)
+          fetch("train_station.#{region}.#{type}")
+        end
+
+        private
+
+        def fill_missing_inputs_with_samples(region, type)
+          regions = %w[germany spain united_kingdom united_states]
+          types = %w[metro railway]
+
+          if region.nil? && type.nil?
+            region = sample(regions)
+            type = sample(types)
+          elsif region.nil?
+            validate_arguments(type, types, 'type')
+            region = sample(regions)
+          elsif type.nil?
+            validate_arguments(region, regions, 'region')
+            type = sample(types)
+          end
+          [region, type]
+        end
+
+        def validate_arguments(argument, correct_values, argument_name)
+          return if correct_values.include?(argument)
+
+          raise ArgumentError, "'#{argument}' not found, #{argument_name} can be blank, or one of the following, as strings: #{correct_values.join(', ')}"
+        end
+      end
+    end
+  end
+end

data/lib/faker/tv_shows/archer.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Faker
+  class TvShows
+    class Archer < Base
+      flexible :archer
+
+      class << self
+        ##
+        # Produces a character from Archer.
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::TvShows::Archer.character #=> "Sterling Archer"
+        #
+        # @faker.version next
+        def character
+          fetch('archer.characters')
+        end
+
+        ##
+        # Produces a location from Archer.
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::TvShows::Archer.location #=> "The Tuntmore Towers"
+        #
+        # @faker.version next
+        def location
+          fetch('archer.locations')
+        end
+
+        ##
+        # Produces a quote from Archer.
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::TvShows::Archer.quote
+        #     #=> "You're not my supervisor!"
+        #
+        # @faker.version next
+        def quote
+          fetch('archer.quotes')
+        end
+      end
+    end
+  end
+end

data/lib/faker/tv_shows/south_park.rb

@@ -32,6 +32,21 @@ module Faker
         def quote
           fetch('south_park.quotes')
         end
+
+        ##
+        # Produces an episode name from South Park.
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::TvShows::SouthPark.episode_name
+        #     #=> "Make Love, Not Warcraft"
+        #
+        # @faker.version next
+
+        def episode_name
+          fetch('south_park.episodes')
+        end
       end
     end
   end

data/lib/faker/version.rb

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

data/lib/faker.rb

@@ -11,14 +11,18 @@ I18n.load_path += Dir[File.join(mydir, 'locales', '**/*.yml')]
 
 module Faker
   module Config
+    @default_locale = nil
+
     class << self
+      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
-        Thread.current[:faker_config_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
@@ -48,19 +52,23 @@ module Faker
 
       ## 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.
@@ -84,7 +92,7 @@ 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