faker 2.2.2

data/lib/faker/books/dune.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Faker
+  class Books
+    class Dune < Base
+      class << self
+        # QUOTED_CHARACTERS = fetch("dune.quotes")
+        # SAYING_SOURCES = %w(translate("faker.dune.sources"))
+
+        def character
+          fetch('dune.characters')
+        end
+
+        def title
+          fetch('dune.titles')
+        end
+
+        def planet
+          fetch('dune.planets')
+        end
+
+        def quote(legacy_character = NOT_GIVEN, character: nil)
+          warn_for_deprecated_arguments do |keywords|
+            keywords << :character if legacy_character != NOT_GIVEN
+          end
+
+          quoted_characters = translate('faker.dune.quotes').keys
+
+          if character.nil?
+            character = sample(quoted_characters).to_s
+          else
+            character = character.to_s.downcase
+
+            unless quoted_characters.include?(character.to_sym)
+              raise ArgumentError,
+                    "Characters quoted can be left blank or #{quoted_characters.join(', ')}"
+            end
+          end
+
+          fetch('dune.quotes.' + character)
+        end
+
+        def saying(legacy_source = NOT_GIVEN, source: nil)
+          warn_for_deprecated_arguments do |keywords|
+            keywords << :source if legacy_source != NOT_GIVEN
+          end
+
+          sourced_sayings = translate('faker.dune.sayings').keys
+
+          if source.nil?
+            source = sample(sourced_sayings).to_s
+          else
+            source = source.to_s.downcase
+
+            unless sourced_sayings.include?(source.to_sym)
+              raise ArgumentError,
+                    "Sources quoted in sayings can be left blank or #{sourced_sayings.join(', ')}"
+            end
+          end
+
+          fetch('dune.sayings.' + source)
+        end
+      end
+    end
+  end
+end

data/lib/faker/books/lovecraft.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Faker
+  class Books
+    class Lovecraft < Base
+      class << self
+        def location
+          fetch('lovecraft.location')
+        end
+
+        def fhtagn(legacy_number = NOT_GIVEN, number: 1)
+          warn_for_deprecated_arguments do |keywords|
+            keywords << :number if legacy_number != NOT_GIVEN
+          end
+
+          Array.new(number) { fetch('lovecraft.fhtagn') }.join('. ')
+        end
+
+        def deity
+          fetch('lovecraft.deity')
+        end
+
+        def tome
+          fetch('lovecraft.tome')
+        end
+
+        def sentence(legacy_word_count = NOT_GIVEN, legacy_random_words_to_add = NOT_GIVEN, word_count: 4, random_words_to_add: 6)
+          warn_for_deprecated_arguments do |keywords|
+            keywords << :word_count if legacy_word_count != 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).to_i, spaces_allowed: true).join(' ').capitalize + '.'
+        end
+
+        def word
+          random_word = sample(translate('faker.lovecraft.words'))
+          random_word =~ /\s/ ? word : random_word
+        end
+
+        def words(legacy_number = NOT_GIVEN, legacy_spaces_allowed = NOT_GIVEN, number: 3, spaces_allowed: false)
+          warn_for_deprecated_arguments do |keywords|
+            keywords << :number if legacy_number != NOT_GIVEN
+            keywords << :spaces_allowed if legacy_spaces_allowed != NOT_GIVEN
+          end
+
+          resolved_num = resolve(number)
+          word_list = translate('faker.lovecraft.words')
+          word_list *= ((resolved_num / word_list.length) + 1)
+
+          return shuffle(word_list)[0, resolved_num] if spaces_allowed
+
+          words = shuffle(word_list)[0, resolved_num]
+          words.each_with_index { |w, i| words[i] = word if w =~ /\s/ }
+        end
+
+        def sentences(legacy_number = NOT_GIVEN, number: 3)
+          warn_for_deprecated_arguments do |keywords|
+            keywords << :number if legacy_number != NOT_GIVEN
+          end
+
+          [].tap do |sentences|
+            1.upto(resolve(number)) do
+              sentences << sentence(word_count: 3)
+            end
+          end
+        end
+
+        def paragraph(legacy_sentence_count = NOT_GIVEN, legacy_random_sentences_to_add = NOT_GIVEN, sentence_count: 3, random_sentences_to_add: 3)
+          warn_for_deprecated_arguments do |keywords|
+            keywords << :sentence_count if legacy_sentence_count != 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).to_i).join(' ')
+        end
+
+        def paragraphs(legacy_number = NOT_GIVEN, number: 3)
+          warn_for_deprecated_arguments do |keywords|
+            keywords << :number if legacy_number != NOT_GIVEN
+          end
+
+          [].tap do |paragraphs|
+            1.upto(resolve(number)) do
+              paragraphs << paragraph(sentence_count: 3)
+            end
+          end
+        end
+
+        def paragraph_by_chars(legacy_characters = NOT_GIVEN, characters: 256)
+          warn_for_deprecated_arguments do |keywords|
+            keywords << :characters if legacy_characters != NOT_GIVEN
+          end
+
+          paragraph = paragraph(sentence_count: 3)
+
+          paragraph += ' ' + paragraph(sentence_count: 3) while paragraph.length < characters
+
+          paragraph[0...characters - 1] + '.'
+        end
+      end
+    end
+  end
+end

data/lib/faker/creature/animal.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Faker
+  class Creature
+    class Animal < Base
+      class << self
+        def name
+          fetch('creature.animal.name')
+        end
+      end
+    end
+  end
+end

data/lib/faker/creature/cat.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Faker
+  class Creature
+    class Cat < Base
+      flexible :cat
+
+      class << self
+        def name
+          fetch('creature.cat.name')
+        end
+
+        def breed
+          fetch('creature.cat.breed')
+        end
+
+        def registry
+          fetch('creature.cat.registry')
+        end
+      end
+    end
+  end
+end

data/lib/faker/creature/dog.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Faker
+  class Creature
+    class Dog < Base
+      flexible :dog
+
+      class << self
+        def name
+          fetch('creature.dog.name')
+        end
+
+        def breed
+          fetch('creature.dog.breed')
+        end
+
+        def sound
+          fetch('creature.dog.sound')
+        end
+
+        def meme_phrase
+          fetch('creature.dog.meme_phrase')
+        end
+
+        def age
+          fetch('creature.dog.age')
+        end
+
+        def gender
+          Faker::Gender.binary_type
+        end
+
+        def coat_length
+          fetch('creature.dog.coat_length')
+        end
+
+        def size
+          fetch('creature.dog.size')
+        end
+      end
+    end
+  end
+end

data/lib/faker/creature/horse.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Faker
+  class Creature
+    class Horse < Base
+      flexible :horse
+
+      class << self
+        def name
+          fetch('creature.horse.name')
+        end
+
+        def breed
+          fetch('creature.horse.breed')
+        end
+      end
+    end
+  end
+end

data/lib/faker/default/address.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Faker
+  class Address < Base
+    flexible :address
+
+    class << self
+      def city(legacy_options = NOT_GIVEN, options: {})
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :options if legacy_options != NOT_GIVEN
+        end
+
+        parse(options[:with_state] ? 'address.city_with_state' : 'address.city')
+      end
+
+      def street_name
+        parse('address.street_name')
+      end
+
+      def street_address(legacy_include_secondary = NOT_GIVEN, include_secondary: false)
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :include_secondary if legacy_include_secondary != NOT_GIVEN
+        end
+
+        numerify(parse('address.street_address') + (include_secondary ? ' ' + secondary_address : ''))
+      end
+
+      def secondary_address
+        bothify(fetch('address.secondary_address'))
+      end
+
+      def building_number
+        bothify(fetch('address.building_number'))
+      end
+
+      def community
+        parse('address.community')
+      end
+
+      def zip_code(legacy_state_abbreviation = NOT_GIVEN, state_abbreviation: '')
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :state_abbreviation if legacy_state_abbreviation != NOT_GIVEN
+        end
+
+        if state_abbreviation.empty?
+          letterified_string = letterify(fetch('address.postcode'))
+          return numerify(letterified_string, leading_zero: true)
+        end
+
+        # provide a zip code that is valid for the state provided
+        # see http://www.fincen.gov/forms/files/us_state_territory_zip_codes.pdf
+        bothify(fetch('address.postcode_by_state.' + state_abbreviation))
+      end
+
+      def time_zone
+        fetch('address.time_zone')
+      end
+
+      alias zip zip_code
+      alias postcode zip_code
+
+      def street_suffix
+        fetch('address.street_suffix')
+      end
+
+      def city_suffix
+        fetch('address.city_suffix')
+      end
+
+      def city_prefix
+        fetch('address.city_prefix')
+      end
+
+      def state_abbr
+        fetch('address.state_abbr')
+      end
+
+      def state
+        fetch('address.state')
+      end
+
+      def country
+        fetch('address.country')
+      end
+
+      def country_by_code(legacy_code = NOT_GIVEN, code: 'US')
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :code if legacy_code != NOT_GIVEN
+        end
+
+        fetch('address.country_by_code.' + code)
+      end
+
+      def country_name_to_code(legacy_name = NOT_GIVEN, name: 'united_states')
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :name if legacy_name != NOT_GIVEN
+        end
+
+        fetch('address.country_by_name.' + name)
+      end
+
+      def country_code
+        fetch('address.country_code')
+      end
+
+      def country_code_long
+        fetch('address.country_code_long')
+      end
+
+      def latitude
+        ((rand * 180) - 90).to_f
+      end
+
+      def longitude
+        ((rand * 360) - 180).to_f
+      end
+
+      def full_address
+        parse('address.full_address')
+      end
+    end
+  end
+end

data/lib/faker/default/alphanumeric.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Faker
+  class Alphanumeric < Base
+    ALPHANUMS = LLetters + Numbers
+
+    class << self
+      def alpha(legacy_number = NOT_GIVEN, number: 32)
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :number if legacy_number != NOT_GIVEN
+        end
+        char_count = resolve(number)
+        return '' if char_count.to_i < 1
+
+        Array.new(char_count) { sample(self::LLetters) }.join
+      end
+
+      ##
+      # Produces a random string of alphanumeric characters
+      #
+      # @param [Integer] number
+      # @param [Integer] min_alpha
+      # @param [Integer] min_numeric
+      #
+      # @return [String]
+      #
+      # @example Faker::Alphanumeric.alphanumeric(number: 10) #=> "3yfq2phxtb"
+      # @example Faker::Alphanumeric.alphanumeric(number: 10, min_alpha: 3) #=> "3yfq2phxtb"
+      # @example Faker::Alphanumeric.alphanumeric(number: 10, min_alpha: 3, min_numeric: 3) #=> "3yfq2phx8b"
+      #
+      # @faker.version 2.1.3
+      def alphanumeric(legacy_number = NOT_GIVEN, number: 32, min_alpha: 0, min_numeric: 0)
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :number if legacy_number != NOT_GIVEN
+        end
+        char_count = resolve(number)
+        return '' if char_count.to_i < 1
+        raise ArgumentError, 'min_alpha must be greater than or equal to 0' if min_alpha&.negative?
+        raise ArgumentError, 'min_numeric must be greater than or equal to 0' if min_numeric&.negative?
+
+        return Array.new(char_count) { sample(ALPHANUMS) }.join if min_alpha.zero? && min_numeric.zero?
+
+        raise ArgumentError, 'min_alpha + min_numeric must be <= number' if min_alpha + min_numeric > char_count
+
+        random_count = char_count - min_alpha - min_numeric
+
+        alphas = Array.new(min_alpha) { sample(self::LLetters) }
+        numbers = Array.new(min_numeric) { sample(self::Numbers) }
+        randoms = Array.new(random_count) { sample(ALPHANUMS) }
+
+        combined = alphas + numbers + randoms
+        combined.shuffle.join
+      end
+    end
+  end
+end