faker 1.9.6 → 2.1.2

data/lib/faker/default/internet.rb

@@ -3,23 +3,23 @@
 module Faker
   class Internet < Base
     class << self
-      def email(name = nil, *separators)
+      def email(name: nil, separators: nil)
         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(name: nil)
+        [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(name: nil)
+        [username(specifier: name), 'example.' + sample(%w[org com net])].join('@')
       end
 
-      def username(specifier = nil, separators = %w[. _])
+      def username(specifier: nil, separators: %w[. _])
         with_locale(:en) do
           return shuffle(specifier.scan(/[[:word:]]+/)).join(sample(separators)).downcase if specifier.respond_to?(:scan)
 
@@ -30,7 +30,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 +39,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,12 +55,13 @@ module Faker
         end
       end
 
-      def password(min_length = 8, max_length = 16, mix_case = true, special_chars = false)
-        temp = Lorem.characters(min_length)
+      def password(min_length: 8, max_length: 16, mix_case: true, special_characters: false)
+        temp = Lorem.characters(number: min_length)
         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
@@ -69,7 +70,7 @@ module Faker
           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 +80,7 @@ module Faker
         temp
       end
 
-      def domain_name(subdomain = false)
+      def domain_name(subdomain: false)
         with_locale(:en) do
           domain_elements = [Char.prepare(domain_word), domain_suffix]
           domain_elements.unshift(Char.prepare(domain_word)) if subdomain
@@ -87,7 +88,7 @@ module Faker
         end
       end
 
-      def fix_umlauts(string = '')
+      def fix_umlauts(string: '')
         Char.fix_umlauts(string)
       end
 
@@ -99,7 +100,7 @@ module Faker
         fetch('internet.domain_suffix')
       end
 
-      def mac_address(prefix = '')
+      def mac_address(prefix: '')
         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 +174,20 @@ module Faker
         "#{ip_v6_address}/#{rand(1..127)}"
       end
 
-      def url(host = domain_name, path = "/#{username}", scheme = 'http')
+      def url(host: domain_name, path: "/#{username}", scheme: 'http')
         "#{scheme}://#{host}#{path}"
       end
 
-      def slug(words = nil, glue = nil)
+      def slug(words: nil, glue: nil)
         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(vendor: nil)
         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,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