faker 2.14.0 → 2.18.0

data/lib/faker.rb

@@ -12,13 +12,12 @@ I18n.load_path += Dir[File.join(mydir, 'locales', '**/*.yml')]
 I18n.reload! if I18n.backend.initialized?
 
 module Faker
-  class Config
+  module Config
     @locale = nil
     @random = nil
 
     class << self
-      attr_writer :locale
-      attr_writer :random
+      attr_writer :locale, :random
 
       def locale
         # Because I18n.locale defaults to :en, if we don't have :en in our available_locales, errors will happen
@@ -30,7 +29,7 @@ module Faker
       end
 
       def random
-        @random || Random::DEFAULT
+        @random || Random.new
       end
     end
   end
@@ -81,13 +80,13 @@ module Faker
       def regexify(reg)
         reg = reg.source if reg.respond_to?(:source) # Handle either a Regexp or a String that looks like a Regexp
         reg
-          .gsub(%r{^\/?\^?}, '').gsub(%r{\$?\/?$}, '') # Ditch the anchors
+          .gsub(%r{^/?\^?}, '').gsub(%r{\$?/?$}, '') # Ditch the anchors
           .gsub(/\{(\d+)\}/, '{\1,\1}').gsub(/\?/, '{0,1}') # All {2} become {2,2} and ? become {0,1}
           .gsub(/(\[[^\]]+\])\{(\d+),(\d+)\}/) { |_match| Regexp.last_match(1) * sample(Array(Range.new(Regexp.last_match(2).to_i, Regexp.last_match(3).to_i))) }                # [12]{1,2} becomes [12] or [12][12]
-          .gsub(/(\([^\)]+\))\{(\d+),(\d+)\}/) { |_match| Regexp.last_match(1) * sample(Array(Range.new(Regexp.last_match(2).to_i, Regexp.last_match(3).to_i))) }                # (12|34){1,2} becomes (12|34) or (12|34)(12|34)
+          .gsub(/(\([^)]+\))\{(\d+),(\d+)\}/) { |_match| Regexp.last_match(1) * sample(Array(Range.new(Regexp.last_match(2).to_i, Regexp.last_match(3).to_i))) }                 # (12|34){1,2} becomes (12|34) or (12|34)(12|34)
           .gsub(/(\\?.)\{(\d+),(\d+)\}/) { |_match| Regexp.last_match(1) * sample(Array(Range.new(Regexp.last_match(2).to_i, Regexp.last_match(3).to_i))) }                      # A{1,2} becomes A or AA or \d{3} becomes \d\d\d
-          .gsub(/\((.*?)\)/) { |match| sample(match.gsub(/[\(\)]/, '').split('|')) } # (this|that) becomes 'this' or 'that'
-          .gsub(/\[([^\]]+)\]/) { |match| match.gsub(/(\w\-\w)/) { |range| sample(Array(Range.new(*range.split('-')))) } } # All A-Z inside of [] become C (or X, or whatever)
+          .gsub(/\((.*?)\)/) { |match| sample(match.gsub(/[()]/, '').split('|')) } # (this|that) becomes 'this' or 'that'
+          .gsub(/\[([^\]]+)\]/) { |match| match.gsub(/(\w-\w)/) { |range| sample(Array(Range.new(*range.split('-')))) } } # All A-Z inside of [] become C (or X, or whatever)
           .gsub(/\[([^\]]+)\]/) { |_match| sample(Regexp.last_match(1).split('')) } # All [ABC] become B (or A or C)
           .gsub('\d') { |_match| sample(Numbers) }
           .gsub('\w') { |_match| sample(Letters) }
@@ -97,7 +96,7 @@ module Faker
       # with an array of values and selecting one of them.
       def fetch(key)
         fetched = sample(translate("faker.#{key}"))
-        if fetched&.match(%r{^\/}) && fetched&.match(%r{\/$}) # A regex
+        if fetched&.match(%r{^/}) && fetched&.match(%r{/$}) # A regex
           regexify(fetched)
         else
           fetched
@@ -109,7 +108,7 @@ module Faker
       def fetch_all(key)
         fetched = translate("faker.#{key}")
         fetched = fetched.last if fetched.size <= 1
-        if !fetched.respond_to?(:sample) && fetched.match(%r{^\/}) && fetched.match(%r{\/$}) # A regex
+        if !fetched.respond_to?(:sample) && fetched.match(%r{^/}) && fetched.match(%r{/$}) # A regex
           regexify(fetched)
         else
           fetched
@@ -121,7 +120,7 @@ module Faker
       # formatted translation: e.g., "#{first_name} #{last_name}".
       def parse(key)
         fetched = fetch(key)
-        parts = fetched.scan(/(\(?)#\{([A-Za-z]+\.)?([^\}]+)\}([^#]+)?/).map do |prefix, kls, meth, etc|
+        parts = fetched.scan(/(\(?)#\{([A-Za-z]+\.)?([^}]+)\}([^#]+)?/).map do |prefix, kls, meth, etc|
           # If the token had a class Prefix (e.g., Name.first_name)
           # grab the constant, otherwise use self
           cls = kls ? Faker.const_get(kls.chop) : self
@@ -165,12 +164,12 @@ module Faker
       end
 
       # Executes block with given locale set.
-      def with_locale(tmp_locale = nil)
+      def with_locale(tmp_locale = nil, &block)
         current_locale = Faker::Config.own_locale
         Faker::Config.locale = tmp_locale
 
         disable_enforce_available_locales do
-          I18n.with_locale(tmp_locale) { yield }
+          I18n.with_locale(tmp_locale, &block)
         end
       ensure
         Faker::Config.locale = current_locale

data/lib/faker/blockchain/aeternity.rb

@@ -14,7 +14,7 @@ module Faker
         #     #=> "ak_zvU8YQLagjcfng7Tg8yCdiZ1rpiWNp1PBn3vtUs44utSvbJVR"
         #
         def address
-          'ak_' + rand_strings
+          "ak_#{rand_strings}"
         end
 
         ##
@@ -27,7 +27,7 @@ module Faker
         #     #=> "th_147nDP22h3pHrLt2qykTH4txUwQh1ccaXp"
         #
         def transaction
-          'th_' + rand_strings(51)
+          "th_#{rand_strings(51)}"
         end
 
         ##
@@ -40,7 +40,7 @@ module Faker
         #     #=> "ct_Hk2JsNeWGEYQEHHQCfcBeGrwbhtYSwFTPdDhW2SvjFYVojyhW"
         #
         def contract
-          'ct_' + rand_strings
+          "ct_#{rand_strings}"
         end
 
         ##
@@ -53,7 +53,7 @@ module Faker
         #     #=> "ok_28QDg7fkF5qiKueSdUvUBtCYPJdmMEoS73CztzXCRAwMGKHKZh"
         #
         def oracle
-          'ok_' + rand_strings(51)
+          "ok_#{rand_strings(51)}"
         end
 
         protected

data/lib/faker/blockchain/bitcoin.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'digest'
+require 'openssl'
 require 'securerandom'
 
 module Faker
@@ -51,7 +51,7 @@ module Faker
         def address_for(network)
           version = PROTOCOL_VERSIONS.fetch(network)
           packed = version.chr + Faker::Config.random.bytes(20)
-          checksum = Digest::SHA2.digest(Digest::SHA2.digest(packed))[0..3]
+          checksum = OpenSSL::Digest::SHA256.digest(OpenSSL::Digest::SHA256.digest(packed))[0..3]
           Faker::Base58.encode(packed + checksum)
         end
       end

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
 
         ##
@@ -98,7 +126,7 @@ module Faker
         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]
+          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
         #
@@ -76,7 +89,7 @@ module Faker
             end
           end
 
-          fetch('dune.quotes.' + character)
+          fetch("dune.quotes.#{character}")
         end
 
         ##
@@ -111,7 +124,7 @@ module Faker
             end
           end
 
-          fetch('dune.sayings.' + source)
+          fetch("dune.sayings.#{source}")
         end
       end
     end

data/lib/faker/books/lovecraft.rb

@@ -68,6 +68,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 +81,18 @@ 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)
+        def sentence(legacy_word_count = NOT_GIVEN, legacy_random_words_to_add = NOT_GIVEN, word_count: 4, random_words_to_add: 6, open_compounds_allowed: true)
           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 + '.'
+          "#{words(number: word_count + rand(random_words_to_add.to_i).to_i, spaces_allowed: open_compounds_allowed).join(' ').capitalize}."
         end
 
         ##
@@ -266,9 +270,9 @@ module Faker
 
           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/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