faker 2.0.0 → 3.8.0

data/lib/faker/default/hobby.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Faker
+  class Hobby < Base
+    flexible :hobby
+
+    class << self
+      ##
+      # Retrieves a typical hobby activity.
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::Hobby.activity #=> "Cooking"
+      #
+      # @faker.version next
+      def activity
+        fetch('hobby.activity')
+      end
+    end
+  end
+end

data/lib/faker/default/house.rb

@@ -3,10 +3,28 @@
 module Faker
   class House < Base
     class << self
+      ##
+      # Produces the name of a piece of furniture.
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::House.furniture #=> "chair"
+      #
+      # @faker.version 1.9.2
       def furniture
         fetch('house.furniture')
       end
 
+      ##
+      # Produces the name of a room in a house.
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::House.room #=> "kitchen"
+      #
+      # @faker.version 1.9.2
       def room
         fetch('house.rooms')
       end

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}>#{Faker::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>#{Faker::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: Faker::Lorem.sentence(word_count: 3), attributes: { class: Faker::Lorem.word, onclick: "#{Faker::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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Faker
-  class IDNumber < Base
+  class IdNumber < Base
     CHECKS = 'TRWAGMYFPDXBNJZSQVHLCKE'
     INVALID_SSN = [
       /0{3}-\d{2}-\d{4}/,
@@ -12,22 +12,68 @@ module Faker
     ].freeze
     ZA_RACE_DIGIT = '8'
     ZA_CITIZENSHIP_DIGITS = %w[0 1].freeze
+    BRAZILIAN_ID_FORMAT = /(\d{1,2})(\d{3})(\d{3})([\dX])/
+    BRAZILIAN_ID_FROM = 10_000_000
+    BRAZILIAN_ID_TO = 99_999_999
+
+    CHILEAN_MODULO = 11
 
     class << self
+      ##
+      # Produces a random valid US Social Security number.
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::IdNumber.valid #=> "552-56-3593"
+      #
+      # @faker.version 1.6.0
       def valid
         _translate('valid')
       end
 
+      ##
+      # Produces a random invalid US Social Security number.
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::IdNumber.invalid #=> "311-72-0000"
+      #
+      # @faker.version 1.6.0
       def invalid
         _translate('invalid')
       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
 
+      ##
+      # Produces a random Spanish citizen identifier (DNI).
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::IdNumber.spanish_citizen_number #=> "53290236-H"
+      #
+      # @faker.version 1.9.0
       def spanish_citizen_number
         num = Faker::Number.number(digits: 8)
         mod = num.to_i % 23
@@ -35,6 +81,15 @@ module Faker
         "#{num}-#{check}"
       end
 
+      ##
+      # Produces a random Spanish foreign born citizen identifier (NIE).
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::IdNumber.spanish_foreign_citizen_number #=> "Z-1600870-Y"
+      #
+      # @faker.version 1.9.0
       def spanish_foreign_citizen_number
         code = 'XYZ'
         digits = Faker::Number.number(digits: 7)
@@ -45,6 +100,16 @@ module Faker
         "#{prefix}-#{digits}-#{check}"
       end
 
+      ##
+      # Produces a random valid South African ID Number.
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::IdNumber.south_african_id_number #=> "8105128870184"
+      #   Faker::IdNumber.valid_south_african_id_number #=> "8105128870184"
+      #
+      # @faker.version 1.9.2
       def valid_south_african_id_number
         id_number = [
           Faker::Date.birthday.strftime('%y%m%d'),
@@ -58,12 +123,21 @@ module Faker
 
       alias south_african_id_number valid_south_african_id_number
 
+      ##
+      # Produces a random invalid South African ID Number.
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::IdNumber.invalid_south_african_id_number #=> "1642972065088"
+      #
+      # @faker.version 1.9.2
       def invalid_south_african_id_number
         invalid_date_of_birth = [
           Faker::Number.number(digits: 2),
           Faker::Number.between(from: 13, to: 99),
           Faker::Number.between(from: 32, to: 99)
-        ].map(&:to_s).join
+        ].join
 
         id_number = [
           invalid_date_of_birth,
@@ -75,6 +149,17 @@ module Faker
         [id_number, south_african_id_checksum_digit(id_number)].join
       end
 
+      ##
+      # Produces a random Brazilian Citizen Number (CPF).
+      #
+      # @param formatted [Boolean] Specifies if the number is formatted with dividers.
+      # @return [String]
+      #
+      # @example
+      #   Faker::IdNumber.brazilian_citizen_number #=> "53540542221"
+      #   Faker::IdNumber.brazilian_citizen_number(formatted: true) #=> "535.405.422-21"
+      #
+      # @faker.version 1.9.2
       def brazilian_citizen_number(formatted: false)
         digits = Faker::Number.leading_zero_number(digits: 9) until digits&.match(/(\d)((?!\1)\d)+/)
         first_digit = brazilian_citizen_number_checksum_digit(digits)
@@ -83,8 +168,166 @@ module Faker
         formatted ? format('%s.%s.%s-%s', *number.scan(/\d{2,3}/).flatten) : number
       end
 
+      alias brazilian_cpf brazilian_citizen_number
+
+      ##
+      # Produces a random Brazilian ID Number (RG).
+      #
+      # @param formatted [Boolean] Specifies if the number is formatted with dividers.
+      # @return [String]
+      #
+      # @example
+      #   Faker::IdNumber.brazilian_id #=> "493054029"
+      #   Faker::IdNumber.brazilian_id(formatted: true) #=> "49.305.402-9"
+      #
+      # @faker.version 2.1.2
+      def brazilian_id(formatted: false)
+        digits = Faker::Number.between(to: BRAZILIAN_ID_FROM, from: BRAZILIAN_ID_TO).to_s
+        check_digit = brazilian_id_checksum_digit(digits)
+        number = [digits, check_digit].join
+        formatted ? format('%s.%s.%s-%s', *number.scan(BRAZILIAN_ID_FORMAT).flatten) : number
+      end
+
+      alias brazilian_rg brazilian_id
+
+      ##
+      # Produces a random Chilean ID (Rut with 8 digits).
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::IdNumber.chilean_id #=> "15620613-K"
+      #
+      # @faker.version 2.1.2
+      def chilean_id
+        digits = Faker::Number.number(digits: 8)
+        verification_code = chilean_verification_code(digits)
+
+        "#{digits}-#{verification_code}"
+      end
+
+      ##
+      # Produces a random Croatian ID number (OIB).
+      #
+      # @param international [Boolean] Specifies whether to add international prefix.
+      # @return [String]
+      #
+      # @example
+      #   Faker::IdNumber.croatian_id #=> "88467617508"
+      #   Faker::IdNumber.croatian_id(international: true) #=> "HR88467617508"
+      #
+      # @faker.version next
+      def croatian_id(international: false)
+        prefix = international ? 'HR' : ''
+        digits = Faker::Number.number(digits: 10).to_s
+        checksum_digit = croatian_id_checksum_digit(digits)
+
+        "#{prefix}#{digits}#{checksum_digit}"
+      end
+
+      ##
+      # Produces a random Danish ID Number (CPR number).
+      # CPR number is 10 digits. Digit 1-6 is the birthdate (format "DDMMYY").
+      # Digit 7-10 is a sequence number.
+      # Digit 7 digit is a control digit that determines the century of birth.
+      # Digit 10 reveals the gender: # even is female, odd is male.
+      #
+      # @param formatted [Boolean] Specifies if the number is formatted with dividers.
+      # @param birthday [Date] Specifies the birthday for the id number.
+      # @param gender [Symbol] Specifies the gender for the id number. Must be one :male or :female if present.
+      # @return [String]
+      #
+      # @example
+      #   Faker::IdNumber.danish_id_number #=> "0503909980"
+      #   Faker::IdNumber.danish_id_number(formatted: true) #=> "050390-9980"
+      #   Faker::IdNumber.danish_id_number(birthday: Date.new(1990, 3, 5)) #=> "0503909980"
+      #   Faker::IdNumber.danish_id_number(gender: :female) #=> "0503909980"
+      #
+      # @faker.version next
+      def danish_id_number(formatted: false, birthday: Faker::Date.birthday, gender: nil)
+        valid_control_digits = danish_control_digits(birthday)
+        control_digit = sample(valid_control_digits)
+        digits = (0..9).to_a
+        gender = gender.to_sym if gender.respond_to?(:to_sym)
+        gender_digit = case gender
+                       when nil
+                         sample(digits)
+                       when :male
+                         sample(digits.select(&:odd?))
+                       when :female
+                         sample(digits.select(&:even?))
+                       else
+                         raise ArgumentError, "Invalid gender #{gender}. Must be one of male, female, or be omitted."
+                       end
+
+        [
+          birthday.strftime('%d%m%y'),
+          formatted ? '-' : '',
+          control_digit,
+          Faker::Number.number(digits: 2),
+          gender_digit
+        ].join
+      end
+
+      ##
+      # Produces a random French social security number (INSEE number).
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::IdNumber.french_insee_number #=> "53290236-H"
+      #
+      # @faker.version next
+      def french_insee_number
+        num = [
+          [1, 2].sample(random: Faker::Config.random), # gender
+          Faker::Number.between(from: 0, to: 99).to_s.rjust(2, '0'), # year of birth
+          Faker::Number.between(from: 1, to: 12).to_s.rjust(2, '0'), # month of birth
+          Faker::Number.number(digits: 5), # place of birth
+          Faker::Number.number(digits: 3) # order number
+        ].join
+        mod = num.to_i % 97
+        check = (97 - mod).to_s.rjust(2, '0')
+        "#{num}#{check}"
+      end
+
       private
 
+      def croatian_id_checksum_digit(digits)
+        control_sum = 10
+
+        digits.chars.map(&:to_i).each do |digit|
+          control_sum += digit
+          control_sum %= 10
+          control_sum = 10 if control_sum.zero?
+          control_sum *= 2
+          control_sum %= 11
+        end
+
+        control_sum = 11 - control_sum
+        control_sum % 10
+      end
+
+      def chilean_verification_code(digits)
+        # First digit is multiplied by 3, second by 2, and so on
+        multiplication_rule = [3, 2, 7, 6, 5, 4, 3, 2]
+        digits_splitted = digits.to_s.chars.map(&:to_i)
+
+        sum = digits_splitted.map.with_index { |digit, index| digit * multiplication_rule[index] }.reduce(:+)
+
+        modulo = sum.modulo(CHILEAN_MODULO)
+        difference = CHILEAN_MODULO - modulo
+
+        case difference
+        when 0..9
+          difference
+        when 10
+          'K'
+        when 11
+          0
+        end
+      end
+
       def south_african_id_checksum_digit(id_number)
         value_parts = id_number.chars
         even_digits = value_parts
@@ -95,7 +338,7 @@ module Faker
                                             .with_index { |_, i| (i + 1).odd? }
 
         sum_of_odd_digits = odd_digits_without_last_character.map(&:to_i).reduce(:+)
-        even_digits_times_two = (even_digits.join('').to_i * 2).to_s
+        even_digits_times_two = (even_digits.join.to_i * 2).to_s
         sum_of_even_digits = even_digits_times_two.chars.map(&:to_i).reduce(:+)
 
         total_sum = sum_of_odd_digits + sum_of_even_digits
@@ -104,13 +347,75 @@ module Faker
       end
 
       def brazilian_citizen_number_checksum_digit(digits)
-        digit_sum = digits.chars.each_with_index.inject(0) do |acc, (digit, i)|
+        checksum = brazilian_document_checksum(digits)
+        brazilian_document_digit(checksum)
+      end
+
+      def brazilian_id_checksum_digit(digits)
+        checksum = brazilian_document_checksum(digits)
+        brazilian_document_digit(checksum, id: true)
+      end
+
+      def brazilian_document_checksum(digits)
+        digits.chars.each_with_index.inject(0) do |acc, (digit, i)|
           acc + digit.to_i * (digits.size + 1 - i)
         end * 10
-        remainder = digit_sum % 11
+      end
+
+      def brazilian_document_digit(checksum, id: false)
+        remainder = checksum % 11
+        id ? brazilian_id_digit(remainder) : brazilian_citizen_number_digit(remainder)
+      end
+
+      def brazilian_citizen_number_digit(remainder)
         remainder == 10 ? '0' : remainder.to_s
       end
 
+      def brazilian_id_digit(remainder)
+        subtraction = 11 - remainder.to_i
+        digits = { 10 => 'X', 11 => '0' }
+        digits.include?(subtraction) ? digits[subtraction] : subtraction.to_s
+      end
+
+      def danish_control_digits(birthday)
+        year = birthday.year
+        century = year.to_s.slice(0, 2).to_i
+        year_digits = year.to_s.slice(2, 2).to_i
+        error_message = "Invalid birthday: #{birthday}. Danish CPR numbers are only distributed to persons born between 1858 and 2057."
+
+        case century
+        when 18
+          # If 5, 6, 7 or 8 and the year numbers are greater than or equal to 58, you were born in 18XX.
+          case year_digits
+          when 58..99
+            [5, 6, 7, 8]
+          else
+            raise ArgumentError, error_message
+          end
+        when 19
+          # If 0, 1, 2 or 3, you are always born in 19XX.
+          # If 4 or 9, you are born in 19XX if the year digits are greater than 36.
+
+          case year_digits
+          when 0..36
+            [0, 1, 2, 3]
+          else # 37..99
+            [0, 1, 2, 3, 4, 9]
+          end
+        else
+          # If 4, 5, 6, 7, 8 or 9 and the year digits are less than or equal to 36, you were born in 20XX.
+          # 5, 6, 7 and 8 are not distributed to persons, with year digits from and including 37 to and including 57.
+          case year_digits
+          when 0..36
+            [4, 5, 6, 7, 8, 9]
+          when 37..57
+            [5, 6, 7, 8]
+          else
+            raise ArgumentError, error_message
+          end
+        end
+      end
+
       def _translate(key)
         parse("id_number.#{key}")
       end