faker 2.1.2 → 2.4.0

data/lib/faker/default/internet.rb

@@ -3,7 +3,12 @@
 module Faker
   class Internet < Base
     class << self
-      def email(name: nil, separators: nil)
+      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(specifier: name, separators: separators), domain_name].join('@')
         else
@@ -11,15 +16,28 @@ module Faker
         end
       end
 
-      def free_email(name: nil)
+      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)
+      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)
 
@@ -55,8 +73,39 @@ module Faker
         end
       end
 
-      def password(min_length: 8, max_length: 16, mix_case: true, special_characters: false)
-        temp = Lorem.characters(number: min_length)
+      ##
+      # 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
+      # rubocop:disable Metrics/ParameterLists
+      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)
+        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?
@@ -65,8 +114,12 @@ module Faker
         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
 
@@ -80,7 +133,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
@@ -88,7 +145,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
 
@@ -100,7 +161,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(':')
@@ -174,11 +239,23 @@ module Faker
         "#{ip_v6_address}/#{rand(1..127)}"
       end
 
-      def url(host: domain_name, path: "/#{username}", scheme: 'http')
+      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(number: 2).join(' ')).delete(',.').gsub(' ', glue).downcase
       end
@@ -187,7 +264,11 @@ module Faker
         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?

data/lib/faker/default/json.rb

@@ -3,7 +3,12 @@ module Faker
     require 'json'
 
     class << self
-      def shallow_json(width: 3, options: { key: 'Name.first_name', value: 'Name.first_name' })
+      def shallow_json(legacy_width = NOT_GIVEN, legacy_options = NOT_GIVEN, width: 3, options: { key: 'Name.first_name', value: 'Name.first_name' })
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :width if legacy_width != NOT_GIVEN
+          keywords << :options if legacy_options != NOT_GIVEN
+        end
+
         options[:key] = 'Faker::' + options[:key]
         options[:value] = 'Faker::' + options[:value]
 
@@ -11,7 +16,19 @@ module Faker
         JSON.generate(hash)
       end
 
-      def add_depth_to_json(json: shallow_json, width: 3, options: { key: 'Name.first_name', value: 'Name.first_name' })
+      # rubocop:disable Metrics/ParameterLists
+      def add_depth_to_json(legacy_json = NOT_GIVEN, legacy_width = NOT_GIVEN, legacy_options = NOT_GIVEN, json: shallow_json, width: 3, options: { key: 'Name.first_name', value: 'Name.first_name' })
+        # rubocop:enable Metrics/ParameterLists
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :json if legacy_json != NOT_GIVEN
+        end
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :width if legacy_width != NOT_GIVEN
+        end
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :options if legacy_options != NOT_GIVEN
+        end
+
         options[:key] = 'Faker::' + options[:key]
         options[:value] = 'Faker::' + options[:value]
 

data/lib/faker/default/lorem.rb

@@ -8,7 +8,12 @@ module Faker
         sample(translate('faker.lorem.words'))
       end
 
-      def words(number: 3, supplemental: false)
+      def words(legacy_number = NOT_GIVEN, legacy_supplemental = NOT_GIVEN, number: 3, supplemental: false)
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :number if legacy_number != NOT_GIVEN
+          keywords << :supplemental if legacy_supplemental != NOT_GIVEN
+        end
+
         resolved_num = resolve(number)
         word_list = (
           translate('faker.lorem.words') +
@@ -22,31 +27,84 @@ module Faker
         sample(Types::CHARACTERS)
       end
 
-      def characters(number: 255)
-        Alphanumeric.alphanumeric(number: number)
+      ##
+      # Produces a random string of alphanumeric characters
+      #
+      # @param number [Integer] The number of characters to generate
+      # @param min_alpha [Integer] The minimum number of alphabetic to add to the string
+      # @param min_numeric [Integer] The minimum number of numbers to add to the string
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::Lorem.characters #=> "uw1ep04lhs0c4d931n1jmrspprf5w..."
+      #   Faker::Lorem.characters(number: 10) #=> "ang9cbhoa8"
+      #   Faker::Lorem.characters(number: 10, min_alpha: 4) #=> "ang9cbhoa8"
+      #   Faker::Lorem.characters(number: 10, min_alpha: 4, min_numeric: 1) #=> "ang9cbhoa8"
+      #
+      # @faker.version 2.1.3
+      def characters(legacy_number = NOT_GIVEN, number: 255, min_alpha: 0, min_numeric: 0)
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :number if legacy_number != NOT_GIVEN
+        end
+
+        Alphanumeric.alphanumeric(number: number, min_alpha: min_alpha, min_numeric: min_numeric)
       end
 
       def multibyte
         sample(translate('faker.lorem.multibyte')).pack('C*').force_encoding('utf-8')
       end
 
-      def sentence(word_count: 4, supplemental: false, random_words_to_add: 0)
+      # rubocop:disable Metrics/ParameterLists
+      def sentence(legacy_word_count = NOT_GIVEN, legacy_supplemental = NOT_GIVEN, legacy_random_words_to_add = NOT_GIVEN, word_count: 4, supplemental: false, random_words_to_add: 0)
+        # rubocop:enable Metrics/ParameterLists
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :word_count if legacy_word_count != NOT_GIVEN
+          keywords << :supplemental if legacy_supplemental != NOT_GIVEN
+          keywords << :random_words_to_add if legacy_random_words_to_add != NOT_GIVEN
+        end
+
         words(number: word_count + rand(random_words_to_add.to_i), supplemental: supplemental).join(' ').capitalize + locale_period
       end
 
-      def sentences(number: 3, supplemental: false)
+      def sentences(legacy_number = NOT_GIVEN, legacy_supplemental = NOT_GIVEN, number: 3, supplemental: false)
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :number if legacy_number != NOT_GIVEN
+          keywords << :supplemental if legacy_supplemental != NOT_GIVEN
+        end
+
         1.upto(resolve(number)).collect { sentence(word_count: 3, supplemental: supplemental) }
       end
 
-      def paragraph(sentence_count: 3, supplemental: false, random_sentences_to_add: 0)
+      # rubocop:disable Metrics/ParameterLists
+      def paragraph(legacy_sentence_count = NOT_GIVEN, legacy_supplemental = NOT_GIVEN, legacy_random_sentences_to_add = NOT_GIVEN, sentence_count: 3, supplemental: false, random_sentences_to_add: 0)
+        # rubocop:enable Metrics/ParameterLists
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :sentence_count if legacy_sentence_count != NOT_GIVEN
+          keywords << :supplemental if legacy_supplemental != NOT_GIVEN
+          keywords << :random_sentences_to_add if legacy_random_sentences_to_add != NOT_GIVEN
+        end
+
         sentences(number: resolve(sentence_count) + rand(random_sentences_to_add.to_i), supplemental: supplemental).join(locale_space)
       end
 
-      def paragraphs(number: 3, supplemental: false)
+      def paragraphs(legacy_number = NOT_GIVEN, legacy_supplemental = NOT_GIVEN, number: 3, supplemental: false)
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :number if legacy_number != NOT_GIVEN
+        end
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :supplemental if legacy_supplemental != NOT_GIVEN
+        end
+
         1.upto(resolve(number)).collect { paragraph(sentence_count: 3, supplemental: supplemental) }
       end
 
-      def paragraph_by_chars(number: 256, supplemental: false)
+      def paragraph_by_chars(legacy_number = NOT_GIVEN, legacy_supplemental = NOT_GIVEN, number: 256, supplemental: false)
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :number if legacy_number != NOT_GIVEN
+          keywords << :supplemental if legacy_supplemental != NOT_GIVEN
+        end
+
         paragraph = paragraph(sentence_count: 3, supplemental: supplemental)
 
         paragraph += ' ' + paragraph(sentence_count: 3, supplemental: supplemental) while paragraph.length < number
@@ -54,11 +112,24 @@ module Faker
         paragraph[0...number - 1] + '.'
       end
 
-      def question(word_count: 4, supplemental: false, random_words_to_add: 0)
+      # rubocop:disable Metrics/ParameterLists
+      def question(legacy_word_count = NOT_GIVEN, legacy_supplemental = NOT_GIVEN, legacy_random_words_to_add = NOT_GIVEN, word_count: 4, supplemental: false, random_words_to_add: 0)
+        # rubocop:enable Metrics/ParameterLists
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :word_count if legacy_word_count != NOT_GIVEN
+          keywords << :supplemental if legacy_supplemental != NOT_GIVEN
+          keywords << :random_words_to_add if legacy_random_words_to_add != NOT_GIVEN
+        end
+
         words(number: word_count + rand(random_words_to_add), supplemental: supplemental).join(' ').capitalize + locale_question_mark
       end
 
-      def questions(number: 3, supplemental: false)
+      def questions(legacy_number = NOT_GIVEN, legacy_supplemental = NOT_GIVEN, number: 3, supplemental: false)
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :number if legacy_number != NOT_GIVEN
+          keywords << :supplemental if legacy_supplemental != NOT_GIVEN
+        end
+
         1.upto(resolve(number)).collect { question(word_count: 3, supplemental: supplemental) }
       end
 

data/lib/faker/default/lorem_flickr.rb

@@ -5,23 +5,56 @@ module Faker
     class << self
       SUPPORTED_COLORIZATIONS = %w[red green blue].freeze
 
-      def image(size: '300x300', search_terms: [], match_all: false)
+      # rubocop:disable Metrics/ParameterLists
+      def image(legacy_size = NOT_GIVEN, legacy_search_terms = NOT_GIVEN, legacy_match_all = NOT_GIVEN, size: '300x300', search_terms: [], match_all: false)
+        # rubocop:enable Metrics/ParameterLists
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :size if legacy_size != NOT_GIVEN
+          keywords << :search_terms if legacy_search_terms != NOT_GIVEN
+          keywords << :match_all if legacy_match_all != NOT_GIVEN
+        end
+
         build_url(size, nil, search_terms, match_all)
       end
 
-      def grayscale_image(size: '300x300', search_terms: ['all'], match_all: false)
+      # rubocop:disable Metrics/ParameterLists
+      def grayscale_image(legacy_size = NOT_GIVEN, legacy_search_terms = NOT_GIVEN, legacy_match_all = NOT_GIVEN, size: '300x300', search_terms: ['all'], match_all: false)
+        # rubocop:enable Metrics/ParameterLists
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :size if legacy_size != NOT_GIVEN
+          keywords << :search_terms if legacy_search_terms != NOT_GIVEN
+          keywords << :match_all if legacy_match_all != NOT_GIVEN
+        end
+
         raise ArgumentError, 'Search terms must be specified for grayscale images' unless search_terms.any?
 
         build_url(size, 'g', search_terms, match_all)
       end
 
-      def pixelated_image(size: '300x300', search_terms: ['all'], match_all: false)
+      # rubocop:disable Metrics/ParameterLists
+      def pixelated_image(legacy_size = NOT_GIVEN, legacy_search_terms = NOT_GIVEN, legacy_match_all = NOT_GIVEN, size: '300x300', search_terms: ['all'], match_all: false)
+        # rubocop:enable Metrics/ParameterLists
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :size if legacy_size != NOT_GIVEN
+          keywords << :search_terms if legacy_search_terms != NOT_GIVEN
+          keywords << :match_all if legacy_match_all != NOT_GIVEN
+        end
+
         raise ArgumentError, 'Search terms must be specified for pixelated images' unless search_terms.any?
 
         build_url(size, 'p', search_terms, match_all)
       end
 
-      def colorized_image(size: '300x300', color: 'red', search_terms: ['all'], match_all: false)
+      # rubocop:disable Metrics/ParameterLists
+      def colorized_image(legacy_size = NOT_GIVEN, legacy_color = NOT_GIVEN, legacy_search_terms = NOT_GIVEN, legacy_match_all = NOT_GIVEN, size: '300x300', color: 'red', search_terms: ['all'], match_all: false)
+        # rubocop:enable Metrics/ParameterLists
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :size if legacy_size != NOT_GIVEN
+          keywords << :color if legacy_color != NOT_GIVEN
+          keywords << :search_terms if legacy_search_terms != NOT_GIVEN
+          keywords << :match_all if legacy_match_all != NOT_GIVEN
+        end
+
         raise ArgumentError, 'Search terms must be specified for colorized images' unless search_terms.any?
         raise ArgumentError, "Supported colorizations are #{SUPPORTED_COLORIZATIONS.join(', ')}" unless SUPPORTED_COLORIZATIONS.include?(color)
 
@@ -33,7 +66,7 @@ module Faker
       def build_url(size, format, search_terms, match_all)
         raise ArgumentError, 'Size should be specified in format 300x300' unless size =~ /^[0-9]+x[0-9]+$/
 
-        url_parts = ['http://loremflickr.com']
+        url_parts = ['https://loremflickr.com']
         url_parts << format
         url_parts += size.split('x')
         url_parts << search_terms.compact.join(',') if search_terms.any?