faker 2.6.0

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,151 @@
+# 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 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
+
+      # 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

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