faker 2.11.0 → 3.4.2

data/lib/faker/blockchain/tezos.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'digest'
+require 'openssl'
 require 'securerandom'
 
 module Faker
@@ -88,6 +88,34 @@ module Faker
           encode_tz(:edsig, 64)
         end
 
+        ##
+        # Produces a random Tezos public key
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::Blockchain::Tezos.public_key
+        #     #=> "edpkuib9x8QXRc5nWwHUg7U1dXsVmaUrUNU5sX9pVEEvwbMVdfMCeq"
+        #
+        # @faker.version 2.15.2
+        def public_key
+          encode_tz(:edpk, 32)
+        end
+
+        ##
+        # Produces a random Tezos public key
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::Blockchain::Tezos.secret_key
+        #     #=> "edsk3HZCAGEGpzQPnQUwQeFY4ESanFhQCgLpKriQw8GHyhKCrjHawv"
+        #
+        # @faker.version 2.15.2
+        def secret_key
+          encode_tz(:edsk, 32)
+        end
+
         protected
 
         ##
@@ -97,8 +125,8 @@ module Faker
         # @return [String]
         def encode_tz(prefix, payload_size)
           prefix = PREFIXES.fetch(prefix)
-          packed = prefix.map(&:chr).join('') + Faker::Config.random.bytes(payload_size)
-          checksum = Digest::SHA2.digest(Digest::SHA2.digest(packed))[0..3]
+          packed = prefix.map(&:chr).join + Faker::Config.random.bytes(payload_size)
+          checksum = OpenSSL::Digest::SHA256.digest(OpenSSL::Digest::SHA256.digest(packed))[0..3]
           Faker::Base58.encode(packed + checksum)
         end
       end

data/lib/faker/books/dune.rb

@@ -30,6 +30,19 @@ module Faker
           fetch('dune.titles')
         end
 
+        ##
+        # Produces the name of a city from Dune
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::Books::Dune.city #=> "Arrakeen"
+        #
+        # @faker.version next
+        def city
+          fetch('dune.cities')
+        end
+
         ##
         # Produces the name of a planet from Dune
         #
@@ -58,11 +71,7 @@ module Faker
         #     #=> "He who controls the spice, controls the universe!"
         #
         # @faker.version 1.9.3
-        def quote(legacy_character = NOT_GIVEN, character: nil)
-          warn_for_deprecated_arguments do |keywords|
-            keywords << :character if legacy_character != NOT_GIVEN
-          end
-
+        def quote(character: nil)
           quoted_characters = translate('faker.dune.quotes').keys
 
           if character.nil?
@@ -76,7 +85,7 @@ module Faker
             end
           end
 
-          fetch('dune.quotes.' + character)
+          fetch("dune.quotes.#{character}")
         end
 
         ##
@@ -93,11 +102,7 @@ module Faker
         #     #=> "May thy knife chip and shatter."
         #
         # @faker.version 1.9.3
-        def saying(legacy_source = NOT_GIVEN, source: nil)
-          warn_for_deprecated_arguments do |keywords|
-            keywords << :source if legacy_source != NOT_GIVEN
-          end
-
+        def saying(source: nil)
           sourced_sayings = translate('faker.dune.sayings').keys
 
           if source.nil?
@@ -111,7 +116,7 @@ module Faker
             end
           end
 
-          fetch('dune.sayings.' + source)
+          fetch("dune.sayings.#{source}")
         end
       end
     end

data/lib/faker/books/lovecraft.rb

@@ -29,11 +29,7 @@ module Faker
         #     #=> "Ph'nglui mglw'nafh Cthulhu R'lyeh wgah'nagl fht...
         #
         # @faker.version 1.9.3
-        def fhtagn(legacy_number = NOT_GIVEN, number: 1)
-          warn_for_deprecated_arguments do |keywords|
-            keywords << :number if legacy_number != NOT_GIVEN
-          end
-
+        def fhtagn(number: 1)
           Array.new(number) { fetch('lovecraft.fhtagn') }.join('. ')
         end
 
@@ -68,6 +64,7 @@ module Faker
         #
         # @param word_count [Integer] The number of words to have in the sentence
         # @param random_words_to_add [Integer]
+        # @param open_compounds_allowed [Boolean] If true, generated sentence can contain words having additional spaces
         #
         # @return [String]
         #
@@ -80,15 +77,13 @@ module Faker
         # @example
         #   Faker::Books::Lovecraft.sentence(word_count: 3, random_words_to_add: 1)
         #     #=> "Amorphous indescribable tenebrous."
+        # @example
+        #   Faker::Books::Lovecraft.sentence(word_count: 3, random_words_to_add: 0, open_compounds_allowed: true)
+        #     #=> "Effulgence unmentionable gambrel."
         #
         # @faker.version 1.9.3
-        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 + '.'
+        def sentence(word_count: 4, random_words_to_add: 6, open_compounds_allowed: true)
+          "#{words(number: word_count + rand(random_words_to_add.to_i).to_i, spaces_allowed: open_compounds_allowed).join(' ').capitalize}."
         end
 
         ##
@@ -134,19 +129,13 @@ module Faker
         #   #   ]
         #
         # @faker.version 1.9.3
-        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
-
+        def words(number: 3, spaces_allowed: false)
           resolved_num = resolve(number)
           word_list = translate('faker.lovecraft.words')
           word_list *= ((resolved_num / word_list.length) + 1)
+          words = sample(word_list, resolved_num)
+          return words if spaces_allowed
 
-          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
 
@@ -172,11 +161,7 @@ module Faker
         #   #   ]
         #
         # @faker.version 1.9.3
-        def sentences(legacy_number = NOT_GIVEN, number: 3)
-          warn_for_deprecated_arguments do |keywords|
-            keywords << :number if legacy_number != NOT_GIVEN
-          end
-
+        def sentences(number: 3)
           [].tap do |sentences|
             1.upto(resolve(number)) do
               sentences << sentence(word_count: 3)
@@ -203,12 +188,7 @@ module Faker
         #     #=> "Stench cyclopean fainted antiquarian nameless. Antiquarian ululate tenebrous non-euclidean effulgence."
         #
         # @faker.version 1.9.3
-        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
-
+        def paragraph(sentence_count: 3, random_sentences_to_add: 3)
           sentences(number: resolve(sentence_count) + rand(random_sentences_to_add.to_i).to_i).join(' ')
         end
 
@@ -234,11 +214,7 @@ module Faker
         #   #   ]
         #
         # @faker.version 1.9.3
-        def paragraphs(legacy_number = NOT_GIVEN, number: 3)
-          warn_for_deprecated_arguments do |keywords|
-            keywords << :number if legacy_number != NOT_GIVEN
-          end
-
+        def paragraphs(number: 3)
           [].tap do |paragraphs|
             1.upto(resolve(number)) do
               paragraphs << paragraph(sentence_count: 3)
@@ -259,16 +235,12 @@ module Faker
         #     #=> "Effulgence madness noisome. Fungus stygian mortal madness amorphous dank. Decadent noisome hideous effulgence. Tentacles charne."
         #
         # @faker.version 1.9.3
-        def paragraph_by_chars(legacy_characters = NOT_GIVEN, characters: 256)
-          warn_for_deprecated_arguments do |keywords|
-            keywords << :characters if legacy_characters != NOT_GIVEN
-          end
-
+        def paragraph_by_chars(characters: 256)
           paragraph = paragraph(sentence_count: 3)
 
-          paragraph += ' ' + paragraph(sentence_count: 3) while paragraph.length < characters
+          paragraph += " #{paragraph(sentence_count: 3)}" while paragraph.length < characters
 
-          paragraph[0...characters - 1] + '.'
+          "#{paragraph[0...characters - 1]}."
         end
       end
     end

data/lib/faker/books/the_kingkiller_chronicle.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Faker
+  class Books
+    class TheKingkillerChronicle < Base
+      class << self
+        ##
+        # Produces the name of a The Kingkiller Chronicle book.
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::Books::TheKingkillerChronicle.book #=> "The Name of the Wind"
+        #
+        # @faker.version next
+        def book
+          fetch('books.the_kingkiller_chronicle.books')
+        end
+
+        ##
+        # Produces the name of a The Kingkiller Chronicle character.
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::Books::TheKingkillerChronicle.character #=> "Kvothe"
+        #
+        # @faker.version next
+        def character
+          fetch('books.the_kingkiller_chronicle.characters')
+        end
+
+        ##
+        # Produces the name of a The Kingkiller Chronicle creature.
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::Books::TheKingkillerChronicle.creature #=> "Scrael"
+        #
+        # @faker.version next
+        def creature
+          fetch('books.the_kingkiller_chronicle.creatures')
+        end
+
+        ##
+        # Produces the name of a The Kingkiller Chronicle location.
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::Books::TheKingkillerChronicle.location #=> "Tarbean"
+        #
+        # @faker.version next
+        def location
+          fetch('books.the_kingkiller_chronicle.locations')
+        end
+      end
+    end
+  end
+end

data/lib/faker/creature/bird.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+module Faker
+  class Creature
+    class Bird < Base
+      flexible :bird
+
+      class << self
+        ##
+        # Produces a random common family name of a bird.
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::Creature::Bird.common_family_name #=> "Owls"
+        #
+        # @faker.version next
+        def common_family_name
+          fetch('creature.bird.common_family_name')
+        end
+
+        ##
+        # Produces a random common taxonomic order from the class Aves
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::Creature::Bird.order #=> "Passeriformes"
+        #
+        # @faker.version next
+        def order
+          orders = I18n.translate('faker.creature.bird.order_common_map').keys
+          sample(orders).to_s
+        end
+
+        ##
+        # Produces a random bird anatomy word
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::Creature::Bird.anatomy #=> "rump"
+        #
+        # @faker.version next
+        def anatomy
+          fetch('creature.bird.anatomy')
+        end
+
+        ##
+        # Produces a random, past tensed bird anatomy word
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::Creature::Bird.anatomy #=> "breasted"
+        #
+        # @faker.version next
+        def anatomy_past_tense
+          fetch('creature.bird.anatomy_past_tense')
+        end
+
+        ##
+        # Produces a random geographical word used in describing birds
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::Creature::Bird.geo #=> "Eurasian"
+        #
+        # @faker.version next
+        def geo
+          fetch('creature.bird.geo')
+        end
+
+        ##
+        # Produces a random color word used in describing birds
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::Creature::Bird.color #=> "ferruginous"
+        #
+        # @faker.version next
+        def color
+          fetch('creature.bird.colors')
+        end
+
+        ##
+        # Produces a random adjective used to described birds
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::Creature::Bird.adjective #=> 'common'
+        #
+        # @faker.version next
+        def adjective
+          fetch('creature.bird.adjectives')
+        end
+
+        ##
+        # Produces a random emotional adjective NOT used to described birds
+        # ...but could be
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::Creature::Bird.emotional_adjective #=> 'cantankerous'
+        #
+        # @faker.version next
+        def emotional_adjective
+          fetch('creature.bird.emotional_adjectives')
+        end
+
+        ##
+        # Produces a random adjective NOT used to described birds
+        # ...but probably shouldn't
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::Creature::Bird.silly_adjective #=> 'drunk'
+        #
+        # @faker.version next
+        def silly_adjective
+          fetch('creature.bird.silly_adjectives')
+        end
+
+        ##
+        # Produces a random common name for a bird
+        #
+        # @param [String | Symbol | nil] tax_order Tax
+        # @return [String]
+        # @raises TypeError If `tax_order` cannot be converted into a Symbol
+        # @raises ArgumentError If `tax_order` is not a valid taxonomic order
+        #
+        # @example
+        #   Faker::Creature::Bird.common_name #=> 'wren'
+        #
+        # @faker.version next
+        def common_name(tax_order = nil)
+          map = translate('faker.creature.bird.order_common_map')
+          if tax_order.nil?
+            sample(map.values.flatten).downcase
+          else
+            raise TypeError, 'tax_order parameter must be symbolizable' \
+              unless tax_order.respond_to?(:to_sym)
+            raise ArgumentError, "#{tax_order} is not a valid taxonomic order" \
+                                 unless map.keys.include?(tax_order.to_sym)
+
+            the_order = translate('faker.creature.bird.order_common_map')[tax_order.to_sym]
+            sample(the_order).downcase
+          end
+        end
+
+        ##
+        # Produces a random and plausible common name for a bird
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::Creature::Bird.plausible_common_name #=> 'Hellinger's Wren'
+        #
+        # @faker.version next
+        def plausible_common_name
+          parse('creature.bird.plausible_common_names').capitalize
+        end
+
+        ##
+        # Produces a random and IMplausible common name for a bird
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::Creature::Bird.implausible_common_name #=> 'Hellinger's Cantankerous Chickadee'
+        #
+        # @faker.version next
+        def implausible_common_name
+          parse('creature.bird.implausible_common_names').capitalize
+        end
+
+        ##
+        # Produces a hash entry with a random order and a random common name
+        # that is of that order
+        #
+        # @return [Hash<order,common_name>]
+        #
+        # @example
+        #  Faker::Creature::Bird.order_with_common_name #=> {
+        #    order: ''Accipitriformes',
+        #    common_name: 'Osprey'
+        # }
+        #
+        # @faker.version next
+        def order_with_common_name(tax_order = nil)
+          map = I18n.translate('faker.creature.bird.order_common_map')
+          o = tax_order.nil? ? order : tax_order
+          { order: o, common_name: sample(map[o.to_sym]) }
+        end
+      end
+    end
+  end
+end

data/lib/faker/default/address.rb

@@ -18,11 +18,7 @@ module Faker
       #     #=> "Northfort, California"
       #
       # @faker.version 0.3.0
-      def city(legacy_options = NOT_GIVEN, options: {})
-        warn_for_deprecated_arguments do |keywords|
-          keywords << :options if legacy_options != NOT_GIVEN
-        end
-
+      def city(options: {})
         parse(options[:with_state] ? 'address.city_with_state' : 'address.city')
       end
 
@@ -49,12 +45,8 @@ module Faker
       #   Faker::Address.street_address #=> "282 Kevin Brook"
       #
       # @faker.version 0.3.0
-      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 : ''))
+      def street_address(include_secondary: false)
+        numerify(parse('address.street_address') + (include_secondary ? " #{secondary_address}" : ''))
       end
 
       ##
@@ -102,7 +94,7 @@ module Faker
       # @return [String]
       #
       # @example
-      # Faker::Address.mail_box #=> "PO Box 123"
+      #   Faker::Address.mail_box #=> "PO Box 123"
       #
       # @faker.version 2.9.1
       def mail_box
@@ -121,19 +113,15 @@ module Faker
       #   Faker::Address.zip_code(state_abbreviation: 'CO') #=> "80011"
       #
       # @faker.version 0.3.0
-      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
-
+      def zip_code(state_abbreviation: '')
         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))
+        # provide a zip code that may be valid for the state provided
+        # note: zip code may appear in the correct format for the state provided but may not be an actual state zip.
+        bothify(fetch("address.postcode_by_state.#{state_abbreviation}"))
       end
 
       ##
@@ -242,12 +230,8 @@ module Faker
       #   Faker::Address.country_by_code(code: 'NL') #=> "Netherlands"
       #
       # @faker.version 1.9.2
-      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)
+      def country_by_code(code: 'US')
+        fetch("address.country_by_code.#{code}")
       end
 
       ##
@@ -260,12 +244,8 @@ module Faker
       #   Faker::Address.country_name_to_code(name: 'united_states') #=> "US"
       #
       # @faker.version 1.9.2
-      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)
+      def country_name_to_code(name: 'united_states')
+        fetch("address.country_by_name.#{name}")
       end
 
       ##
@@ -333,6 +313,36 @@ module Faker
       def full_address
         parse('address.full_address')
       end
+
+      ##
+      # Produces Address hash of required fields
+      #
+      # @return [Hash]
+      #
+      # @example
+      #   Faker::Address.full_address_as_hash(:longitude,
+      #                                       :latitude,
+      #                                       :country_name_to_code,
+      #                                       country_name_to_code: {name: 'united_states'})
+      #     #=> {:longitude=>-101.74428917174603, :latitude=>-37.40056749089944, :country_name_to_code=>"US"}
+      #
+      #  Faker::Address.full_address_as_hash(:full_address)
+      #     #=> {:full_address=>"87635 Rice Street, Lake Brentonton, OR 61896-5968"}
+      #
+      #  Faker::Address.full_address_as_hash(:city, :time_zone)
+      #     #=> {:city=>"East Faustina", :time_zone=>"America/Mexico_City"}
+      #
+      #  Faker::Address.full_address_as_hash(:street_address, street_address: {include_secondary: true})
+      #     #=> {:street_address=>"29423 Kenneth Causeway Suite 563"}
+      #
+      # @faker.version 2.13.0
+      def full_address_as_hash(*attrs, **attrs_params)
+        attrs.map!(&:to_sym)
+        attrs_params.transform_keys!(&:to_sym)
+        attrs.map do |attr|
+          { "#{attr}": attrs_params[attr] ? send(attr, **attrs_params[attr]) : send(attr) }
+        end.reduce({}, :merge)
+      end
     end
   end
 end

data/lib/faker/default/adjective.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Faker
+  class Adjective < Base
+    flexible :adjective
+
+    class << self
+      ##
+      # Produces a positive adjective.
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::Adjective.positive #=> "Kind"
+      #
+      # @faker.version next
+      def positive
+        fetch('adjective.positive')
+      end
+
+      ##
+      # Produces a negative adjective.
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::Adjective.negative #=> "Creepy"
+      #
+      # @faker.version next
+      def negative
+        fetch('adjective.negative')
+      end
+    end
+  end
+end

data/lib/faker/default/alphanumeric.rb

@@ -19,10 +19,7 @@ module Faker
       #   Faker::Alphanumeric.alpha(number: 10) #=> "zlvubkrwga"
       #
       # @faker.version 1.9.2
-      def alpha(legacy_number = NOT_GIVEN, number: 32)
-        warn_for_deprecated_arguments do |keywords|
-          keywords << :number if legacy_number != NOT_GIVEN
-        end
+      def alpha(number: 32)
         char_count = resolve(number)
         return '' if char_count.to_i < 1
 
@@ -46,10 +43,7 @@ module Faker
       #   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
+      def alphanumeric(number: 32, min_alpha: 0, min_numeric: 0)
         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?