faker 1.9.6 → 2.0.0

data/lib/faker/default/invoice.rb

@@ -6,13 +6,13 @@ module Faker
 
     class << self
       # Generate random amount between values with 2 decimals
-      def amount_between(from = 0, to = 0)
+      def amount_between(from: 0, to: 0)
         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(ref: '')
         ref = reference if ref.empty?
 
         'RF' + iban_checksum('RF', ref) + ref
@@ -20,7 +20,7 @@ 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(ref: '')
         pattern = fetch('invoice.reference.pattern')
 
         ref = Base.regexify(/#{pattern}/) if ref.empty?

data/lib/faker/default/json.rb

@@ -3,7 +3,7 @@ module Faker
     require 'json'
 
     class << self
-      def shallow_json(width = 3, options = { key: 'Name.first_name', value: 'Name.first_name' })
+      def shallow_json(width: 3, options: { key: 'Name.first_name', value: 'Name.first_name' })
         options[:key] = 'Faker::' + options[:key]
         options[:value] = 'Faker::' + options[:value]
 
@@ -11,7 +11,7 @@ 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' })
+      def add_depth_to_json(json: shallow_json, width: 3, options: { key: 'Name.first_name', value: 'Name.first_name' })
         options[:key] = 'Faker::' + options[:key]
         options[:value] = 'Faker::' + options[:value]
 

data/lib/faker/default/lorem.rb

@@ -8,8 +8,8 @@ module Faker
         sample(translate('faker.lorem.words'))
       end
 
-      def words(num = 3, supplemental = false)
-        resolved_num = resolve(num)
+      def words(number: 3, supplemental: false)
+        resolved_num = resolve(number)
         word_list = (
           translate('faker.lorem.words') +
           (supplemental ? translate('faker.lorem.supplemental') : [])
@@ -22,44 +22,44 @@ module Faker
         sample(Types::CHARACTERS)
       end
 
-      def characters(char_count = 255)
-        Alphanumeric.alphanumeric(char_count)
+      def characters(number: 255)
+        Alphanumeric.alphanumeric(number: number)
       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)
-        words(word_count + rand(random_words_to_add.to_i), supplemental).join(' ').capitalize + locale_period
+      def sentence(word_count: 4, supplemental: false, random_words_to_add: 0)
+        words(number: word_count + rand(random_words_to_add.to_i), supplemental: supplemental).join(' ').capitalize + locale_period
       end
 
-      def sentences(sentence_count = 3, supplemental = false)
-        1.upto(resolve(sentence_count)).collect { sentence(3, supplemental) }
+      def sentences(number: 3, supplemental: false)
+        1.upto(resolve(number)).collect { sentence(word_count: 3, supplemental: supplemental) }
       end
 
-      def paragraph(sentence_count = 3, supplemental = false, random_sentences_to_add = 0)
-        sentences(resolve(sentence_count) + rand(random_sentences_to_add.to_i), supplemental).join(locale_space)
+      def paragraph(sentence_count: 3, supplemental: false, random_sentences_to_add: 0)
+        sentences(number: resolve(sentence_count) + rand(random_sentences_to_add.to_i), supplemental: supplemental).join(locale_space)
       end
 
-      def paragraphs(paragraph_count = 3, supplemental = false)
-        1.upto(resolve(paragraph_count)).collect { paragraph(3, supplemental) }
+      def paragraphs(number: 3, supplemental: false)
+        1.upto(resolve(number)).collect { paragraph(sentence_count: 3, supplemental: supplemental) }
       end
 
-      def paragraph_by_chars(chars = 256, supplemental = false)
-        paragraph = paragraph(3, supplemental)
+      def paragraph_by_chars(number: 256, supplemental: false)
+        paragraph = paragraph(sentence_count: 3, supplemental: supplemental)
 
-        paragraph += ' ' + paragraph(3, supplemental) while paragraph.length < chars
+        paragraph += ' ' + paragraph(sentence_count: 3, supplemental: supplemental) while paragraph.length < number
 
-        paragraph[0...chars - 1] + '.'
+        paragraph[0...number - 1] + '.'
       end
 
-      def question(word_count = 4, supplemental = false, random_words_to_add = 0)
-        words(word_count + rand(random_words_to_add), supplemental).join(' ').capitalize + locale_question_mark
+      def question(word_count: 4, supplemental: false, random_words_to_add: 0)
+        words(number: word_count + rand(random_words_to_add), supplemental: supplemental).join(' ').capitalize + locale_question_mark
       end
 
-      def questions(question_count = 3, supplemental = false)
-        1.upto(resolve(question_count)).collect { question(3, supplemental) }
+      def questions(number: 3, supplemental: false)
+        1.upto(resolve(number)).collect { question(word_count: 3, supplemental: supplemental) }
       end
 
       private

data/lib/faker/default/lorem_flickr.rb

@@ -5,23 +5,23 @@ module Faker
     class << self
       SUPPORTED_COLORIZATIONS = %w[red green blue].freeze
 
-      def image(size = '300x300', search_terms = [], match_all = false)
+      def image(size: '300x300', search_terms: [], match_all: false)
         build_url(size, nil, search_terms, match_all)
       end
 
-      def grayscale_image(size = '300x300', search_terms = ['all'], match_all = false)
+      def grayscale_image(size: '300x300', search_terms: ['all'], match_all: false)
         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)
+      def pixelated_image(size: '300x300', search_terms: ['all'], match_all: false)
         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)
+      def colorized_image(size: '300x300', color: 'red', search_terms: ['all'], match_all: false)
         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)
 

data/lib/faker/default/lorem_pixel.rb

@@ -18,7 +18,7 @@ module Faker
                                 transport].freeze
 
       # rubocop:disable Metrics/ParameterLists
-      def image(size = '300x300', is_gray = false, category = nil, number = nil, text = nil, secure: true)
+      def image(size: '300x300', is_gray: false, category: nil, number: nil, text: nil, secure: true)
         raise ArgumentError, 'Size should be specified in format 300x300' unless size =~ /^[0-9]+x[0-9]+$/
         raise ArgumentError, "Supported categories are #{SUPPORTED_CATEGORIES.join(', ')}" unless category.nil? || SUPPORTED_CATEGORIES.include?(category)
         raise ArgumentError, 'Category required when number is passed' if !number.nil? && category.nil?

data/lib/faker/default/markdown.rb

@@ -8,7 +8,7 @@ module Faker
       end
 
       def emphasis
-        paragraph = Faker::Lorem.paragraph(3)
+        paragraph = Faker::Lorem.paragraph(sentence_count: 3)
         words = paragraph.split(' ')
         position = rand(0..words.length - 1)
         formatting = fetch('markdown.emphasis')
@@ -21,7 +21,7 @@ module Faker
 
         result = []
         number.times do |i|
-          result << "#{i}. #{Faker::Lorem.sentence(1)} \n"
+          result << "#{i}. #{Faker::Lorem.sentence(word_count: 1)} \n"
         end
         result.join('')
       end
@@ -31,17 +31,17 @@ module Faker
 
         result = []
         number.times do |_i|
-          result << "* #{Faker::Lorem.sentence(1)} \n"
+          result << "* #{Faker::Lorem.sentence(word_count: 1)} \n"
         end
         result.join('')
       end
 
       def inline_code
-        "`#{Faker::Lorem.sentence(1)}`"
+        "`#{Faker::Lorem.sentence(word_count: 1)}`"
       end
 
       def block_code
-        "```ruby\n#{Lorem.sentence(1)}\n```"
+        "```ruby\n#{Lorem.sentence(word_count: 1)}\n```"
       end
 
       def table
@@ -59,11 +59,11 @@ module Faker
         send(method_list[rand(0..method_list.length - 1)])
       end
 
-      def sandwich(sentences = 3, repeat = 1)
+      def sandwich(sentences: 3, repeat: 1)
         text_block = []
         text_block << headers
         repeat.times do
-          text_block << Faker::Lorem.paragraph(sentences)
+          text_block << Faker::Lorem.paragraph(sentence_count: sentences)
           text_block << random
         end
         text_block.join("\n")

data/lib/faker/default/measurement.rb

@@ -6,35 +6,35 @@ module Faker
       ALL = 'all'
       NONE = 'none'
 
-      def height(amount = rand(10))
+      def height(amount: rand(10))
         define_measurement_locale(amount, 'height')
       end
 
-      def length(amount = rand(10))
+      def length(amount: rand(10))
         define_measurement_locale(amount, 'length')
       end
 
-      def volume(amount = rand(10))
+      def volume(amount: rand(10))
         define_measurement_locale(amount, 'volume')
       end
 
-      def weight(amount = rand(10))
+      def weight(amount: rand(10))
         define_measurement_locale(amount, 'weight')
       end
 
-      def metric_height(amount = rand(10))
+      def metric_height(amount: rand(10))
         define_measurement_locale(amount, 'metric_height')
       end
 
-      def metric_length(amount = rand(10))
+      def metric_length(amount: rand(10))
         define_measurement_locale(amount, 'metric_length')
       end
 
-      def metric_volume(amount = rand(10))
+      def metric_volume(amount: rand(10))
         define_measurement_locale(amount, 'metric_volume')
       end
 
-      def metric_weight(amount = rand(10))
+      def metric_weight(amount: rand(10))
         define_measurement_locale(amount, 'metric_weight')
       end
 

data/lib/faker/default/name.rb

@@ -5,8 +5,6 @@ module Faker
     flexible :name
 
     class << self
-      extend Gem::Deprecate
-
       def name
         parse('name.name')
       end
@@ -48,8 +46,8 @@ module Faker
         fetch('name.suffix')
       end
 
-      def initials(character_count = 3)
-        (0...character_count).map { rand(65..90).chr }.join
+      def initials(number: 3)
+        (0...number).map { rand(65..90).chr }.join
       end
     end
   end

data/lib/faker/default/nhs.rb

@@ -7,15 +7,15 @@ module Faker
         base_number = rand(400_000_001...499_999_999)
         # If the check digit is equivalent to 10, the number is invalid.
         # See https://en.wikipedia.org/wiki/NHS_number
-        base_number -= 1 if check_digit(base_number) == 10
-        "#{base_number}#{check_digit(base_number)}".to_s
-                                                   .chars
-                                                   .insert(3, ' ')
-                                                   .insert(7, ' ')
-                                                   .join('')
+        base_number -= 1 if check_digit(number: base_number) == 10
+        "#{base_number}#{check_digit(number: base_number)}".to_s
+                                                           .chars
+                                                           .insert(3, ' ')
+                                                           .insert(7, ' ')
+                                                           .join('')
       end
 
-      def check_digit(number = 0)
+      def check_digit(number: 0)
         sum = 0
         number.to_s.chars.each_with_index do |digit, idx|
           position = idx + 1

data/lib/faker/default/number.rb

@@ -3,82 +3,88 @@
 module Faker
   class Number < Base
     class << self
-      extend Gem::Deprecate
+      def number(digits: 10)
+        return if digits < 1
+        return 0 if digits == 1
 
-      def number(digits = 10)
-        num = ''
-
-        if digits > 1
-          num = non_zero_digit
-          digits -= 1
-        end
-
-        num + (1..digits).collect { digit }.join
+        # Ensure the first digit is not zero
+        ([non_zero_digit] + generate(digits - 1)).join.to_i
       end
 
-      def leading_zero_number(digits = 10)
+      def leading_zero_number(digits: 10)
         '0' + (2..digits).collect { digit }.join
       end
 
-      def decimal_part(digits = 10)
+      def decimal_part(digits: 10)
         num = ''
         if digits > 1
           num = non_zero_digit
           digits -= 1
         end
-        leading_zero_number(digits) + num
+        leading_zero_number(digits: digits) + num.to_s
       end
 
-      def decimal(l_digits = 5, r_digits = 2)
-        l_d = number(l_digits)
-        r_d = decimal_part(r_digits)
-
-        "#{l_d}.#{r_d}"
+      def decimal(l_digits: 5, r_digits: 2)
+        l_d = number(digits: l_digits)
+        r_d = if r_digits == 1
+                generate(r_digits)
+              else
+                # Ensure the last digit is not zero
+                # so it does not get truncated on converting to float
+                generate(r_digits - 1).join + non_zero_digit.to_s
+              end
+        "#{l_d}.#{r_d}".to_f
       end
 
       def non_zero_digit
-        rand(1..9).to_s
+        rand(1..9)
       end
 
       def digit
-        rand(10).to_s
+        rand(10)
       end
 
-      def hexadecimal(digits = 6)
+      def hexadecimal(digits: 6)
         hex = ''
         digits.times { hex += rand(15).to_s(16) }
         hex
       end
 
-      def normal(mean = 1, standard_deviation = 1)
+      def normal(mean: 1, standard_deviation: 1)
         theta = 2 * Math::PI * rand
         rho = Math.sqrt(-2 * Math.log(1 - rand))
         scale = standard_deviation * rho
         mean + scale * Math.cos(theta)
       end
 
-      def between(from = 1.00, to = 5000.00)
+      def between(from: 1.00, to: 5000.00)
         Faker::Base.rand_in_range(from, to)
       end
 
-      def within(range = 1.00..5000.00)
-        between(range.min, range.max)
+      def within(range: 1.00..5000.00)
+        between(from: range.min, to: range.max)
       end
 
-      def positive(from = 1.00, to = 5000.00)
-        random_number = between(from, to)
+      def positive(from: 1.00, to: 5000.00)
+        random_number = between(from: from, to: to)
 
         greater_than_zero(random_number)
       end
 
-      def negative(from = -5000.00, to = -1.00)
-        random_number = between(from, to)
+      def negative(from: -5000.00, to: -1.00)
+        random_number = between(from: from, to: to)
 
         less_than_zero(random_number)
       end
 
       private
 
+      def generate(count)
+        return [] if count.zero?
+
+        Array.new(count) { digit }
+      end
+
       def greater_than_zero(number)
         should_be(number, :>)
       end
@@ -94,9 +100,6 @@ module Faker
           number * -1
         end
       end
-
-      deprecate :decimal_part, nil, 2019, 06
-      deprecate :leading_zero_number, nil, 2019, 06
     end
   end
 end

data/lib/faker/default/omniauth.rb

@@ -10,12 +10,12 @@ module Faker
 
     def initialize(name: nil, email: nil)
       @name = name || "#{Name.first_name} #{Name.last_name}"
-      @email = email || Internet.safe_email(self.name)
+      @email = email || Internet.safe_email(name: self.name)
       @first_name, @last_name = self.name.split
     end
 
     class << self
-      def google(name: nil, email: nil, uid: Number.number(9))
+      def google(name: nil, email: nil, uid: Number.number(digits: 9).to_s)
         auth = Omniauth.new(name: name, email: email)
         {
           provider: 'google_oauth2',
@@ -44,7 +44,7 @@ module Faker
               profile: "https://plus.google.com/#{uid}",
               picture: image,
               gender: gender,
-              birthday: Date.backward(36_400).strftime('%Y-%m-%d'),
+              birthday: Date.backward(days: 36_400).strftime('%Y-%m-%d'),
               local: 'en',
               hd: "#{Company.name.downcase}.com"
             },
@@ -52,7 +52,7 @@ module Faker
               'iss' => 'accounts.google.com',
               'at_hash' => Crypto.md5,
               'email_verified' => true,
-              'sub' => Number.number(28).to_s,
+              'sub' => Number.number(digits: 28).to_s,
               'azp' => 'APP_ID',
               'email' => auth.email,
               'aud' => 'APP_ID',
@@ -64,7 +64,7 @@ module Faker
         }
       end
 
-      def facebook(name: nil, email: nil, username: nil, uid: Number.number(7))
+      def facebook(name: nil, email: nil, username: nil, uid: Number.number(digits: 7).to_s)
         auth = Omniauth.new(name: name, email: email)
         username ||= "#{auth.first_name.downcase[0]}#{auth.last_name.downcase}"
         {
@@ -92,7 +92,7 @@ module Faker
               link: "http://www.facebook.com/#{username}",
               username: username,
               location: {
-                id: Number.number(9),
+                id: Number.number(digits: 9).to_s,
                 name: city_state
               },
               gender: gender,
@@ -106,7 +106,7 @@ module Faker
         }
       end
 
-      def twitter(name: nil, nickname: nil, uid: Number.number(6))
+      def twitter(name: nil, nickname: nil, uid: Number.number(digits: 6).to_s)
         auth = Omniauth.new(name: name)
         nickname ||= auth.name.downcase.delete(' ')
         location = city_state
@@ -179,7 +179,7 @@ module Faker
         }
       end
 
-      def linkedin(name: nil, email: nil, uid: Number.number(6))
+      def linkedin(name: nil, email: nil, uid: Number.number(digits: 6).to_s)
         auth = Omniauth.new(name: name, email: email)
         first_name = auth.first_name.downcase
         last_name = auth.last_name.downcase
@@ -242,7 +242,7 @@ module Faker
         }
       end
 
-      def github(name: nil, email: nil, uid: Number.number(8))
+      def github(name: nil, email: nil, uid: Number.number(digits: 8).to_s)
         auth = Omniauth.new(name: name, email: email)
         login = auth.name.downcase.tr(' ', '-')
         html_url = "https://github.com/#{login}"
@@ -293,8 +293,8 @@ module Faker
               public_gists: random_number_from_range(1..1000),
               followers: random_number_from_range(1..1000),
               following: random_number_from_range(1..1000),
-              created_at: Time.backward(36_400).iso8601,
-              updated_at: Time.backward(2).iso8601
+              created_at: Time.backward(days: 36_400).iso8601,
+              updated_at: Time.backward(days: 2).iso8601
             }
           }
         }