faker 2.2.2

data/lib/faker/default/lorem_pixel.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Faker
+  class LoremPixel < Base
+    class << self
+      SUPPORTED_CATEGORIES = %w[abstract
+                                animals
+                                business
+                                cats
+                                city
+                                food
+                                nightlife
+                                fashion
+                                people
+                                nature
+                                sports
+                                technics
+                                transport].freeze
+
+      # rubocop:disable Metrics/ParameterLists
+      def image(legacy_size = NOT_GIVEN, legacy_is_gray = NOT_GIVEN, legacy_category = NOT_GIVEN, legacy_number = NOT_GIVEN, legacy_text = NOT_GIVEN, legacy_secure = NOT_GIVEN, size: '300x300', is_gray: false, category: nil, number: nil, text: nil, secure: true)
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :size if legacy_size != NOT_GIVEN
+          keywords << :is_gray if legacy_is_gray != NOT_GIVEN
+          keywords << :category if legacy_category != NOT_GIVEN
+          keywords << :number if legacy_number != NOT_GIVEN
+          keywords << :text if legacy_text != NOT_GIVEN
+          keywords << :secure if legacy_secure != NOT_GIVEN
+        end
+
+        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?
+        raise ArgumentError, 'Number must be between 1 and 10' unless number.nil? || (1..10).cover?(number)
+        raise ArgumentError, 'Category and number must be passed when text is passed' if !text.nil? && number.nil? && category.nil?
+
+        url_parts = secure ? ['https:/'] : ['http:/']
+        url_parts << ['lorempixel.com']
+        url_parts << 'g' if is_gray
+        url_parts += size.split('x')
+        url_parts += [category, number, text].compact
+        url_parts.join('/')
+      end
+      # rubocop:enable Metrics/ParameterLists
+    end
+  end
+end

data/lib/faker/default/markdown.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Faker
+  class Markdown < Base
+    class << self
+      def headers
+        "#{fetch('markdown.headers')} #{Lorem.word.capitalize}"
+      end
+
+      def emphasis
+        paragraph = Faker::Lorem.paragraph(sentence_count: 3)
+        words = paragraph.split(' ')
+        position = rand(0..words.length - 1)
+        formatting = fetch('markdown.emphasis')
+        words[position] = "#{formatting}#{words[position]}#{formatting}"
+        words.join(' ')
+      end
+
+      def ordered_list
+        number = rand(1..10)
+
+        result = []
+        number.times do |i|
+          result << "#{i}. #{Faker::Lorem.sentence(word_count: 1)} \n"
+        end
+        result.join('')
+      end
+
+      def unordered_list
+        number = rand(1..10)
+
+        result = []
+        number.times do |_i|
+          result << "* #{Faker::Lorem.sentence(word_count: 1)} \n"
+        end
+        result.join('')
+      end
+
+      def inline_code
+        "`#{Faker::Lorem.sentence(word_count: 1)}`"
+      end
+
+      def block_code
+        "```ruby\n#{Lorem.sentence(word_count: 1)}\n```"
+      end
+
+      def table
+        table = []
+        3.times do
+          table << "#{Lorem.word} | #{Lorem.word} | #{Lorem.word}"
+        end
+        table.insert(1, '---- | ---- | ----')
+        table.join("\n")
+      end
+
+      def random(*args)
+        method_list = available_methods
+        args&.each { |ex| method_list.delete_if { |meth| meth == ex.to_sym } }
+        send(method_list[rand(0..method_list.length - 1)])
+      end
+
+      def sandwich(legacy_sentences = NOT_GIVEN, legacy_repeat = NOT_GIVEN, sentences: 3, repeat: 1)
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :sentences if legacy_sentences != NOT_GIVEN
+          keywords << :repeat if legacy_repeat != NOT_GIVEN
+        end
+
+        text_block = []
+        text_block << headers
+        repeat.times do
+          text_block << Faker::Lorem.paragraph(sentence_count: sentences)
+          text_block << random
+        end
+        text_block.join("\n")
+      end
+
+      private
+
+      def available_methods
+        Markdown.public_methods(false) - Base.methods
+      end
+    end
+  end
+end

data/lib/faker/default/marketing.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Faker
+  class Marketing < Base
+    flexible :marketing
+
+    class << self
+      def buzzwords
+        fetch('marketing.buzzwords')
+      end
+    end
+  end
+end

data/lib/faker/default/measurement.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Faker
+  class Measurement < Base
+    class << self
+      ALL = 'all'
+      NONE = 'none'
+
+      def height(legacy_amount = NOT_GIVEN, amount: rand(10))
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :amount if legacy_amount != NOT_GIVEN
+        end
+
+        define_measurement_locale(amount, 'height')
+      end
+
+      def length(legacy_amount = NOT_GIVEN, amount: rand(10))
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :amount if legacy_amount != NOT_GIVEN
+        end
+
+        define_measurement_locale(amount, 'length')
+      end
+
+      def volume(legacy_amount = NOT_GIVEN, amount: rand(10))
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :amount if legacy_amount != NOT_GIVEN
+        end
+
+        define_measurement_locale(amount, 'volume')
+      end
+
+      def weight(legacy_amount = NOT_GIVEN, amount: rand(10))
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :amount if legacy_amount != NOT_GIVEN
+        end
+
+        define_measurement_locale(amount, 'weight')
+      end
+
+      def metric_height(legacy_amount = NOT_GIVEN, amount: rand(10))
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :amount if legacy_amount != NOT_GIVEN
+        end
+
+        define_measurement_locale(amount, 'metric_height')
+      end
+
+      def metric_length(legacy_amount = NOT_GIVEN, amount: rand(10))
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :amount if legacy_amount != NOT_GIVEN
+        end
+
+        define_measurement_locale(amount, 'metric_length')
+      end
+
+      def metric_volume(legacy_amount = NOT_GIVEN, amount: rand(10))
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :amount if legacy_amount != NOT_GIVEN
+        end
+
+        define_measurement_locale(amount, 'metric_volume')
+      end
+
+      def metric_weight(legacy_amount = NOT_GIVEN, amount: rand(10))
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :amount if legacy_amount != NOT_GIVEN
+        end
+
+        define_measurement_locale(amount, 'metric_weight')
+      end
+
+      private
+
+      def check_for_plural(text, number)
+        if number && number != 1
+          make_plural(text)
+        else
+          text
+        end
+      end
+
+      def define_measurement_locale(amount, locale)
+        ensure_valid_amount(amount)
+        if amount == ALL
+          make_plural(fetch("measurement.#{locale}"))
+        elsif amount == NONE
+          fetch("measurement.#{locale}")
+        else
+          locale = check_for_plural(fetch("measurement.#{locale}"), amount)
+
+          "#{amount} #{locale}"
+        end
+      end
+
+      def ensure_valid_amount(amount)
+        raise ArgumentError, 'invalid amount' unless amount == NONE || amount == ALL || amount.is_a?(Integer) || amount.is_a?(Float)
+      end
+
+      def make_plural(text)
+        case text
+        when 'foot'
+          'feet'
+        when 'inch'
+          'inches'
+        when 'fluid ounce'
+          'fluid ounces'
+        when 'metric ton'
+          'metric tons'
+        else
+          "#{text}s"
+        end
+      end
+    end
+  end
+end

data/lib/faker/default/military.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Faker
+  class Military < Base
+    class << self
+      def army_rank
+        fetch('military.army_rank')
+      end
+
+      def marines_rank
+        fetch('military.marines_rank')
+      end
+
+      def navy_rank
+        fetch('military.navy_rank')
+      end
+
+      def air_force_rank
+        fetch('military.air_force_rank')
+      end
+
+      def dod_paygrade
+        fetch('military.dod_paygrade')
+      end
+    end
+  end
+end

data/lib/faker/default/name.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Faker
+  class Name < Base
+    flexible :name
+
+    class << self
+      def name
+        parse('name.name')
+      end
+
+      def name_with_middle
+        parse('name.name_with_middle')
+      end
+
+      def first_name
+        if parse('name.first_name').empty?
+          fetch('name.first_name')
+        else
+          parse('name.first_name')
+        end
+      end
+
+      def male_first_name
+        fetch('name.male_first_name')
+      end
+      alias first_name_men male_first_name
+      alias masculine_name male_first_name
+
+      def female_first_name
+        fetch('name.female_first_name')
+      end
+      alias first_name_women female_first_name
+      alias feminine_name female_first_name
+
+      def last_name
+        parse('name.last_name')
+      end
+      alias middle_name last_name
+
+      def prefix
+        fetch('name.prefix')
+      end
+
+      def suffix
+        fetch('name.suffix')
+      end
+
+      def initials(legacy_number = NOT_GIVEN, number: 3)
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :number if legacy_number != NOT_GIVEN
+        end
+
+        (0...number).map { rand(65..90).chr }.join
+      end
+    end
+  end
+end

data/lib/faker/default/nation.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Faker
+  class Nation < Base
+    flexible :nation
+    class << self
+      # Fetch random nationality
+      def nationality
+        fetch('nation.nationality')
+      end
+
+      # Fetch random national flag emoji
+      def flag
+        sample(translate('faker.nation.flag')).pack('C*').force_encoding('utf-8')
+      end
+
+      # Fetch random language
+      def language
+        fetch('nation.language')
+      end
+
+      # Fetch random capital city
+      def capital_city
+        fetch('nation.capital_city')
+      end
+
+      # Fetch random natinal sport
+      def national_sport
+        fetch('team.sport')
+      end
+    end
+  end
+end

data/lib/faker/default/nato_phonetic_alphabet.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Faker
+  class NatoPhoneticAlphabet < Base
+    class << self
+      def code_word
+        fetch('nato_phonetic_alphabet.code_word')
+      end
+    end
+  end
+end

data/lib/faker/default/nhs.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Faker
+  class NationalHealthService < Base
+    class << self
+      def british_number
+        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(number: base_number) == 10
+        "#{base_number}#{check_digit(number: base_number)}".to_s
+                                                           .chars
+                                                           .insert(3, ' ')
+                                                           .insert(7, ' ')
+                                                           .join('')
+      end
+
+      def check_digit(legacy_number = NOT_GIVEN, number: 0)
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :number if legacy_number != NOT_GIVEN
+        end
+
+        sum = 0
+        number.to_s.chars.each_with_index do |digit, idx|
+          position = idx + 1
+          sum += (digit.to_i * (11 - position))
+        end
+        result = 11 - (sum % 11)
+
+        # A value of 11 is considered the same as 0
+        # See https://en.wikipedia.org/wiki/NHS_number
+        return 0 if result == 11
+
+        result
+      end
+    end
+  end
+end

data/lib/faker/default/number.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module Faker
+  class Number < Base
+    class << self
+      def number(legacy_digits = NOT_GIVEN, digits: 10)
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :digits if legacy_digits != NOT_GIVEN
+        end
+
+        return if digits < 1
+        return rand(0..9).round if digits == 1
+
+        # Ensure the first digit is not zero
+        ([non_zero_digit] + generate(digits - 1)).join.to_i
+      end
+
+      def leading_zero_number(legacy_digits = NOT_GIVEN, digits: 10)
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :digits if legacy_digits != NOT_GIVEN
+        end
+
+        '0' + (2..digits).collect { digit }.join
+      end
+
+      def decimal_part(legacy_digits = NOT_GIVEN, digits: 10)
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :digits if legacy_digits != NOT_GIVEN
+        end
+
+        num = ''
+        if digits > 1
+          num = non_zero_digit
+          digits -= 1
+        end
+        leading_zero_number(digits: digits) + num.to_s
+      end
+
+      def decimal(legacy_l_digits = NOT_GIVEN, legacy_r_digits = NOT_GIVEN, l_digits: 5, r_digits: 2)
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :l_digits if legacy_l_digits != NOT_GIVEN
+          keywords << :r_digits if legacy_r_digits != NOT_GIVEN
+        end
+
+        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)
+      end
+
+      def digit
+        rand(10)
+      end
+
+      def hexadecimal(legacy_digits = NOT_GIVEN, digits: 6)
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :digits if legacy_digits != NOT_GIVEN
+        end
+
+        hex = ''
+        digits.times { hex += rand(15).to_s(16) }
+        hex
+      end
+
+      def normal(legacy_mean = NOT_GIVEN, legacy_standard_deviation = NOT_GIVEN, mean: 1, standard_deviation: 1)
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :mean if legacy_mean != NOT_GIVEN
+          keywords << :standard_deviation if legacy_standard_deviation != NOT_GIVEN
+        end
+
+        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(legacy_from = NOT_GIVEN, legacy_to = NOT_GIVEN, from: 1.00, to: 5000.00)
+        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)
+      end
+
+      def within(legacy_range = NOT_GIVEN, range: 1.00..5000.00)
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :range if legacy_range != NOT_GIVEN
+        end
+
+        between(from: range.min, to: range.max)
+      end
+
+      def positive(legacy_from = NOT_GIVEN, legacy_to = NOT_GIVEN, from: 1.00, to: 5000.00)
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :from if legacy_from != NOT_GIVEN
+          keywords << :to if legacy_to != NOT_GIVEN
+        end
+
+        random_number = between(from: from, to: to)
+
+        greater_than_zero(random_number)
+      end
+
+      def negative(legacy_from = NOT_GIVEN, legacy_to = NOT_GIVEN, from: -5000.00, to: -1.00)
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :from if legacy_from != NOT_GIVEN
+          keywords << :to if legacy_to != NOT_GIVEN
+        end
+
+        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
+
+      def less_than_zero(number)
+        should_be(number, :<)
+      end
+
+      def should_be(number, method_to_compare)
+        if number.send(method_to_compare, 0)
+          number
+        else
+          number * -1
+        end
+      end
+    end
+  end
+end