faker 2.2.2

data/lib/faker/default/invoice.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Faker
+  class Invoice < Base
+    flexible :invoice
+
+    class << self
+      # Generate random amount between values with 2 decimals
+      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(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
+      end
+
+      # Payment references have some rules in certain countries
+      # ref is optional so that we can create unit tests
+      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?
+
+        # If reference contains reserved '#' characters we need to calculate check_digits as well
+        check_digit_match = ref.match(/#+/)
+        if check_digit_match
+          # Get the method for selected language
+          check_digit_method = fetch('invoice.reference.check_digit_method')
+
+          # Calculate the check digit with matching method name
+          # Trim all '#' from the reference before calculating that
+          check_digit = send(check_digit_method, ref.tr('#', ''))
+
+          # Make sure that our check digit is as long as all of the '###' we found
+          check_digit = check_digit.to_s.rjust(check_digit_match[0].length, '0')
+
+          # Replace all of the
+          ref = ref.sub(check_digit_match[0], check_digit)
+        end
+
+        ref
+      end
+
+      private
+
+      # Calculates the mandatory checksum in 3rd and 4th characters in IBAN format
+      # source: https://en.wikipedia.org/wiki/International_Bank_Account_Number#Validating_the_IBAN
+      def iban_checksum(country_code, account)
+        # Converts letters to numbers according the iban rules, A=10..Z=35
+        account_to_number = "#{account}#{country_code}00".upcase.chars.map do |d|
+          d =~ /[A-Z]/ ? (d.ord - 55).to_s : d
+        end.join.to_i
+
+        # This is answer to (iban_to_num + checksum) % 97 == 1
+        checksum = (1 - account_to_number) % 97
+
+        # Use leftpad to make the size always to 2
+        checksum.to_s.rjust(2, '0')
+      end
+
+      # 731 Method
+      # Source: https://wiki.xmldation.com/support/fk/finnish_reference_number
+      def method_731(base)
+        weighted_sum = calculate_weighted_sum(base, [7, 3, 1])
+        mod10_remainder(weighted_sum)
+      end
+
+      # Norsk Modulus 10 - KIDMOD10
+      def kidmod10(base)
+        weighted_sum = calculate_weighted_sum(base, [1, 2])
+        mod10_remainder(weighted_sum)
+      end
+
+      # Calculates weigthed sum
+      #
+      # For example with 12345678, [1,2]
+      # Ref.num. 1 2 3 4 5 6 7 8
+      # Multipl. 1 2 1 2 1 2 1 2
+      # Total 1+ 4+ 3+ 8+ 5+1+2+ 7+1+6 = 38
+      def calculate_weighted_sum(base, weight_factors)
+        base.to_s.reverse.each_char.with_index.map do |digit, index|
+          digit.to_i * weight_factors.at(index % weight_factors.length)
+        end.reduce(:+) # reduce(:+) = sum() but with better ruby version support
+      end
+
+      # MOD-10 - remainder
+      def mod10_remainder(number)
+        -number % 10
+      end
+    end
+  end
+end

data/lib/faker/default/job.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Faker
+  class Job < Base
+    flexible :job
+
+    class << self
+      def title
+        parse('job.title')
+      end
+
+      def position
+        fetch('job.position')
+      end
+
+      def field
+        fetch('job.field')
+      end
+
+      def key_skill
+        fetch('job.key_skills')
+      end
+    end
+  end
+end

data/lib/faker/default/json.rb

@@ -0,0 +1,87 @@
+module Faker
+  class Json < Base
+    require 'json'
+
+    class << self
+      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]
+
+        hash = build_shallow_hash(width, options)
+        JSON.generate(hash)
+      end
+
+      # 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]
+
+        hash = JSON.parse(json)
+        hash.each do |key, _|
+          add_hash_to_bottom(hash, [key], width, options)
+        end
+        JSON.generate(hash)
+      end
+
+      private
+
+      def build_shallow_hash(width, options)
+        key = options[:key]
+        value = options[:value]
+
+        hash = {}
+        width.times do
+          hash[eval(key)] = eval(value)
+        end
+        hash
+      end
+
+      def add_hash_to_bottom(hash, key_array, width, options)
+        key_string = build_keys_from_array(key_array)
+        if eval("hash#{key_string}").is_a?(::Hash)
+          eval("hash#{key_string}").each do |key, _|
+            key_array << key
+            add_hash_to_bottom(hash, key_array, width, options)
+          end
+        else
+          add_hash(key_array, hash, width, options)
+          key_array.pop
+        end
+      end
+
+      def add_hash(key_array, hash, width, options)
+        string_to_eval = 'hash'
+        key_array.length.times do |index|
+          string_to_eval << "['#{key_array[index]}']"
+        end
+        string_to_eval << " = #{build_shallow_hash(width, options)}"
+        eval(string_to_eval)
+        hash
+      end
+
+      def build_keys_from_array(key_array)
+        key_string = ''
+        key_array.each do |value|
+          key_string << "['#{value}']"
+        end
+        key_string
+      end
+    end
+  end
+end

data/lib/faker/default/kpop.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Faker
+  class Kpop < Base
+    class << self
+      def i_groups
+        fetch('kpop.i_groups')
+      end
+
+      def ii_groups
+        fetch('kpop.ii_groups')
+      end
+
+      def iii_groups
+        fetch('kpop.iii_groups')
+      end
+
+      def girl_groups
+        fetch('kpop.girl_groups')
+      end
+
+      def boy_bands
+        fetch('kpop.boy_bands')
+      end
+
+      def solo
+        fetch('kpop.solo')
+      end
+    end
+  end
+end

data/lib/faker/default/lorem.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module Faker
+  # Based on Perl's Text::Lorem
+  class Lorem < Base
+    class << self
+      def word
+        sample(translate('faker.lorem.words'))
+      end
+
+      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') +
+          (supplemental ? translate('faker.lorem.supplemental') : [])
+        )
+        word_list *= ((resolved_num / word_list.length) + 1)
+        shuffle(word_list)[0, resolved_num]
+      end
+
+      def character
+        sample(Types::CHARACTERS)
+      end
+
+      ##
+      # Produces a random string of alphanumeric characters
+      #
+      # @param [Integer] number
+      # @param [Integer] min_alpha
+      # @param [Integer] min_numeric
+      #
+      # @return [String]
+      #
+      # @example Faker::Lorem.characters #=> "uw1ep04lhs0c4d931n1jmrspprf5wrj85fefue0y7y6m56b6omquh7br7dhqijwlawejpl765nb1716idmp3xnfo85v349pzy2o9rir23y2qhflwr71c1585fnynguiphkjm8p0vktwitcsm16lny7jzp9t4drwav3qmhz4yjq4k04x14gl6p148hulyqioo72tf8nwrxxcclfypz2lc58lsibgfe5w5p0xv95peafjjmm2frkhdc6duoky0aha"
+      # @example Faker::Lorem.characters(number: 10) #=> "ang9cbhoa8"
+      # @example Faker::Lorem.characters(number: 10, min_alpha: 4) #=> "ang9cbhoa8"
+      # @example 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
+
+      # 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(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
+
+      # 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(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(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
+
+        paragraph[0...number - 1] + '.'
+      end
+
+      # 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(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
+
+      private
+
+      def locale_period
+        translate('faker.lorem.punctuation.period') || '.'
+      end
+
+      def locale_space
+        translate('faker.lorem.punctuation.space') || ' '
+      end
+
+      def locale_question_mark
+        translate('faker.lorem.punctuation.question_mark') || '?'
+      end
+    end
+  end
+end

data/lib/faker/default/lorem_flickr.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Faker
+  class LoremFlickr < Base
+    class << self
+      SUPPORTED_COLORIZATIONS = %w[red green blue].freeze
+
+      # 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
+
+      # 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
+
+      # 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
+
+      # 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)
+
+        build_url(size, color, search_terms, match_all)
+      end
+
+      private
+
+      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 = ['https://loremflickr.com']
+        url_parts << format
+        url_parts += size.split('x')
+        url_parts << search_terms.compact.join(',') if search_terms.any?
+        url_parts << 'all' if match_all
+        url_parts.compact.join('/')
+      end
+    end
+  end
+end