faker 1.9.6 → 2.7.0

data/lib/faker/default/id_number.rb

@@ -12,6 +12,11 @@ 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])/.freeze
+    BRAZILIAN_ID_FROM = 10_000_000
+    BRAZILIAN_ID_TO = 99_999_999
+
+    CHILEAN_MODULO = 11
 
     class << self
       def valid
@@ -29,7 +34,7 @@ module Faker
       end
 
       def spanish_citizen_number
-        num = Faker::Number.number(8)
+        num = Faker::Number.number(digits: 8)
         mod = num.to_i % 23
         check = CHECKS[mod]
         "#{num}-#{check}"
@@ -37,7 +42,7 @@ module Faker
 
       def spanish_foreign_citizen_number
         code = 'XYZ'
-        digits = Faker::Number.number(7)
+        digits = Faker::Number.number(digits: 7)
         prefix = code[rand(code.length)]
         prefix_val = 'XYZ'.index(prefix).to_s
         mod = "#{prefix_val}#{digits}".to_i % 23
@@ -48,7 +53,7 @@ module Faker
       def valid_south_african_id_number
         id_number = [
           Faker::Date.birthday.strftime('%y%m%d'),
-          Faker::Number.number(4),
+          Faker::Number.number(digits: 4),
           ZA_CITIZENSHIP_DIGITS.sample(random: Faker::Config.random),
           ZA_RACE_DIGIT
         ].join
@@ -60,14 +65,14 @@ module Faker
 
       def invalid_south_african_id_number
         invalid_date_of_birth = [
-          Faker::Number.number(2),
-          Faker::Number.between(13, 99),
-          Faker::Number.between(32, 99)
+          Faker::Number.number(digits: 2),
+          Faker::Number.between(from: 13, to: 99),
+          Faker::Number.between(from: 32, to: 99)
         ].map(&:to_s).join
 
         id_number = [
           invalid_date_of_birth,
-          Faker::Number.number(4),
+          Faker::Number.number(digits: 4),
           ZA_CITIZENSHIP_DIGITS.sample(random: Faker::Config.random),
           ZA_RACE_DIGIT
         ].join
@@ -75,16 +80,62 @@ module Faker
         [id_number, south_african_id_checksum_digit(id_number)].join
       end
 
-      def brazilian_citizen_number(formatted: false)
-        digits = Faker::Number.leading_zero_number(9) until digits&.match(/(\d)((?!\1)\d)+/)
+      def brazilian_citizen_number(legacy_formatted = NOT_GIVEN, formatted: false)
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :formatted if legacy_formatted != NOT_GIVEN
+        end
+
+        digits = Faker::Number.leading_zero_number(digits: 9) until digits&.match(/(\d)((?!\1)\d)+/)
         first_digit = brazilian_citizen_number_checksum_digit(digits)
         second_digit = brazilian_citizen_number_checksum_digit(digits + first_digit)
         number = [digits, first_digit, second_digit].join
         formatted ? format('%s.%s.%s-%s', *number.scan(/\d{2,3}/).flatten) : number
       end
 
+      alias brazilian_cpf brazilian_citizen_number
+
+      def brazilian_id(legacy_formatted = NOT_GIVEN, formatted: false)
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :formatted if legacy_formatted != NOT_GIVEN
+        end
+
+        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
+
+      def chilean_id
+        digits = Faker::Number.number(digits: 8)
+        verification_code = chilean_verification_code(digits)
+
+        digits.to_s + '-' + verification_code.to_s
+      end
+
       private
 
+      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
@@ -104,13 +155,36 @@ 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 _translate(key)
         parse("id_number.#{key}")
       end

data/lib/faker/default/industry_segments.rb

@@ -5,18 +5,54 @@ module Faker
     flexible :industry_segments
 
     class << self
+      ##
+      # Produces the name of an industry.
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::IndustrySegments.industry #=> "Basic Materials"
+      #
+      # @faker.version 1.9.2
       def industry
         fetch('industry_segments.industry')
       end
 
+      ##
+      # Produces the name of a super-sector of an industry.
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::IndustrySegments.super_sector #=> "Basic Resources"
+      #
+      # @faker.version 1.9.2
       def super_sector
         fetch('industry_segments.super_sector')
       end
 
+      ##
+      # Produces the name of a sector of an industry.
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::IndustrySegments.sector #=> "Industrial Metals & Mining"
+      #
+      # @faker.version 1.9.2
       def sector
         fetch('industry_segments.sector')
       end
 
+      ##
+      # Produces the name of a subsector of an industry.
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::IndustrySegments.industry #=> "Basic Materials"
+      #
+      # @faker.version 1.9.2
       def sub_sector
         fetch('industry_segments.sub_sector')
       end

data/lib/faker/default/internet.rb

@@ -3,23 +3,41 @@
 module Faker
   class Internet < Base
     class << self
-      def email(name = nil, *separators)
+      def email(legacy_name = NOT_GIVEN, legacy_separators = NOT_GIVEN, name: nil, separators: nil)
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :name if legacy_name != NOT_GIVEN
+          keywords << :separators if legacy_separators != NOT_GIVEN
+        end
+
         if separators
-          [username(name, separators), domain_name].join('@')
+          [username(specifier: name, separators: separators), domain_name].join('@')
         else
-          [username(name), domain_name].join('@')
+          [username(specifier: name), domain_name].join('@')
         end
       end
 
-      def free_email(name = nil)
-        [username(name), fetch('internet.free_email')].join('@')
+      def free_email(legacy_name = NOT_GIVEN, name: nil)
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :name if legacy_name != NOT_GIVEN
+        end
+
+        [username(specifier: name), fetch('internet.free_email')].join('@')
       end
 
-      def safe_email(name = nil)
-        [username(name), 'example.' + sample(%w[org com net])].join('@')
+      def safe_email(legacy_name = NOT_GIVEN, name: nil)
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :name if legacy_name != NOT_GIVEN
+        end
+
+        [username(specifier: name), 'example.' + sample(%w[org com net])].join('@')
       end
 
-      def username(specifier = nil, separators = %w[. _])
+      def username(legacy_specifier = NOT_GIVEN, legacy_separators = NOT_GIVEN, specifier: nil, separators: %w[. _])
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :specifier if legacy_specifier != NOT_GIVEN
+          keywords << :separators if legacy_separators != NOT_GIVEN
+        end
+
         with_locale(:en) do
           return shuffle(specifier.scan(/[[:word:]]+/)).join(sample(separators)).downcase if specifier.respond_to?(:scan)
 
@@ -30,7 +48,7 @@ module Faker
             tries = 0 # Don't try forever in case we get something like 1_000_000.
             result = nil
             loop do
-              result = username(nil, separators)
+              result = username(specifier: nil, separators: separators)
               tries += 1
               break unless result.length < specifier && tries < 7
             end
@@ -39,7 +57,7 @@ module Faker
             tries = 0
             result = nil
             loop do
-              result = username(specifier.min, separators)
+              result = username(specifier: specifier.min, separators: separators)
               tries += 1
               break unless !specifier.include?(result.length) && tries < 7
             end
@@ -55,21 +73,59 @@ module Faker
         end
       end
 
-      def password(min_length = 8, max_length = 16, mix_case = true, special_chars = false)
-        temp = Lorem.characters(min_length)
+      # rubocop:disable Metrics/ParameterLists
+
+      ##
+      # Produces a randomized string of characters suitable for passwords
+      #
+      # @param min_length [Integer] The minimum length of the password
+      # @param max_length [Integer] The maximum length of the password
+      # @param mix_case [Boolean] Toggles if uppercased letters are allowed. If true, at least one will be added.
+      # @param special_characters [Boolean] Toggles if special characters are allowed. If true, at least one will be added.
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::Internet.password #=> "Vg5mSvY1UeRg7"
+      # @example
+      #   Faker::Internet.password(min_length: 8) #=> "YfGjIk0hGzDqS0"
+      # @example
+      #   Faker::Internet.password(min_length: 10, max_length: 20) #=> "EoC9ShWd1hWq4vBgFw"
+      # @example
+      #   Faker::Internet.password(min_length: 10, max_length: 20, mix_case: true) #=> "3k5qS15aNmG"
+      # @example
+      #   Faker::Internet.password(min_length: 10, max_length: 20, mix_case: true, special_characters: true) #=> "*%NkOnJsH4"
+      #
+      # @faker.version 2.1.3
+      def password(legacy_min_length = NOT_GIVEN, legacy_max_length = NOT_GIVEN, legacy_mix_case = NOT_GIVEN, legacy_special_characters = NOT_GIVEN, min_length: 8, max_length: 16, mix_case: true, special_characters: false)
+        # rubocop:enable Metrics/ParameterLists
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :min_length if legacy_min_length != NOT_GIVEN
+          keywords << :max_length if legacy_max_length != NOT_GIVEN
+          keywords << :mix_case if legacy_mix_case != NOT_GIVEN
+          keywords << :special_characters if legacy_special_characters != NOT_GIVEN
+        end
+
+        min_alpha = mix_case ? 2 : 0
+        temp = Lorem.characters(number: min_length, min_alpha: min_alpha)
         diff_length = max_length - min_length
+
         if diff_length.positive?
           diff_rand = rand(diff_length + 1)
-          temp += Lorem.characters(diff_rand)
+          temp += Lorem.characters(number: diff_rand)
         end
 
         if mix_case
+          alpha_count = 0
           temp.chars.each_with_index do |char, index|
-            temp[index] = char.upcase if index.even?
+            if char =~ /[[:alpha:]]/
+              temp[index] = char.upcase if alpha_count.even?
+              alpha_count += 1
+            end
           end
         end
 
-        if special_chars
+        if special_characters
           chars = %w[! @ # $ % ^ & *]
           rand(1..min_length).times do |i|
             temp[i] = chars[rand(chars.length)]
@@ -79,7 +135,11 @@ module Faker
         temp
       end
 
-      def domain_name(subdomain = false)
+      def domain_name(legacy_subdomain = NOT_GIVEN, subdomain: false)
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :subdomain if legacy_subdomain != NOT_GIVEN
+        end
+
         with_locale(:en) do
           domain_elements = [Char.prepare(domain_word), domain_suffix]
           domain_elements.unshift(Char.prepare(domain_word)) if subdomain
@@ -87,7 +147,11 @@ module Faker
         end
       end
 
-      def fix_umlauts(string = '')
+      def fix_umlauts(legacy_string = NOT_GIVEN, string: '')
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :string if legacy_string != NOT_GIVEN
+        end
+
         Char.fix_umlauts(string)
       end
 
@@ -99,7 +163,11 @@ module Faker
         fetch('internet.domain_suffix')
       end
 
-      def mac_address(prefix = '')
+      def mac_address(legacy_prefix = NOT_GIVEN, prefix: '')
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :prefix if legacy_prefix != NOT_GIVEN
+        end
+
         prefix_digits = prefix.split(':').map { |d| d.to_i(16) }
         address_digits = Array.new((6 - prefix_digits.size)) { rand(256) }
         (prefix_digits + address_digits).map { |d| format('%02x', d) }.join(':')
@@ -173,20 +241,37 @@ module Faker
         "#{ip_v6_address}/#{rand(1..127)}"
       end
 
-      def url(host = domain_name, path = "/#{username}", scheme = 'http')
+      # rubocop:disable Metrics/ParameterLists
+      def url(legacy_host = NOT_GIVEN, legacy_path = NOT_GIVEN, legacy_scheme = NOT_GIVEN, host: domain_name, path: "/#{username}", scheme: 'http')
+        # rubocop:enable Metrics/ParameterLists
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :host if legacy_host != NOT_GIVEN
+          keywords << :path if legacy_path != NOT_GIVEN
+          keywords << :scheme if legacy_scheme != NOT_GIVEN
+        end
+
         "#{scheme}://#{host}#{path}"
       end
 
-      def slug(words = nil, glue = nil)
+      def slug(legacy_words = NOT_GIVEN, legacy_glue = NOT_GIVEN, words: nil, glue: nil)
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :words if legacy_words != NOT_GIVEN
+          keywords << :glue if legacy_glue != NOT_GIVEN
+        end
+
         glue ||= sample(%w[- _])
-        (words || Faker::Lorem.words(2).join(' ')).delete(',.').gsub(' ', glue).downcase
+        (words || Faker::Lorem.words(number: 2).join(' ')).delete(',.').gsub(' ', glue).downcase
       end
 
       def device_token
         shuffle(rand(16**64).to_s(16).rjust(64, '0').chars.to_a).join
       end
 
-      def user_agent(vendor = nil)
+      def user_agent(legacy_vendor = NOT_GIVEN, vendor: nil)
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :vendor if legacy_vendor != NOT_GIVEN
+        end
+
         agent_hash = translate('faker.internet.user_agent')
         agents = vendor.respond_to?(:to_sym) && agent_hash[vendor.to_sym] || agent_hash[sample(agent_hash.keys)]
         sample(agents)

data/lib/faker/default/invoice.rb

@@ -6,13 +6,22 @@ module Faker
 
     class << self
       # Generate random amount between values with 2 decimals
-      def amount_between(from = 0, to = 0)
+      def amount_between(legacy_from = NOT_GIVEN, legacy_to = NOT_GIVEN, from: 0, to: 0)
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :from if legacy_from != NOT_GIVEN
+          keywords << :to if legacy_to != NOT_GIVEN
+        end
+
         Faker::Base.rand_in_range(from, to).round(2)
       end
 
       # International bank slip reference https://en.wikipedia.org/wiki/Creditor_Reference
       # ref is optional so that we can create unit tests
-      def creditor_reference(ref = '')
+      def creditor_reference(legacy_ref = NOT_GIVEN, ref: '')
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :ref if legacy_ref != NOT_GIVEN
+        end
+
         ref = reference if ref.empty?
 
         'RF' + iban_checksum('RF', ref) + ref
@@ -20,7 +29,11 @@ module Faker
 
       # Payment references have some rules in certain countries
       # ref is optional so that we can create unit tests
-      def reference(ref = '')
+      def reference(legacy_ref = NOT_GIVEN, ref: '')
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :ref if legacy_ref != NOT_GIVEN
+        end
+
         pattern = fetch('invoice.reference.pattern')
 
         ref = Base.regexify(/#{pattern}/) if ref.empty?