faker 1.9.1 → 1.9.2

data/lib/faker.rb

@@ -1,4 +1,4 @@
-mydir = __dir__
+# frozen_string_literal: true
 
 begin
   require 'psych'
@@ -7,11 +7,11 @@ end
 require 'i18n'
 require 'set' # Fixes a bug in i18n 0.6.11
 
-if I18n.respond_to?(:enforce_available_locales=)
-  I18n.enforce_available_locales = true
-end
-I18n.load_path += Dir[File.join(mydir, 'locales', '**/*.yml')]
-I18n.reload! if I18n.backend.initialized?
+# require helper files
+Dir.glob(File.join(File.dirname(__FILE__), 'helpers', '*.rb')).sort.each { |file| require file }
+
+# load locales via I18n.backend
+I18n.backend = I18n::Backend::Chain.new(I18n.backend, Faker::I18nBackend.new)
 
 module Faker
   class Config
@@ -45,6 +45,7 @@ module Faker
       ## by default numerify results do not start with a zero
       def numerify(number_string, leading_zero: false)
         return number_string.gsub(/#/) { rand(10).to_s } if leading_zero
+
         number_string.sub(/#/) { rand(1..9).to_s }.gsub(/#/) { rand(10).to_s }
       end
 
@@ -94,7 +95,7 @@ module Faker
       # with an array of values and selecting one of them.
       def fetch(key)
         fetched = sample(translate("faker.#{key}"))
-        if fetched && fetched.match(%r{^\/}) && fetched.match(%r{\/$}) # A regex
+        if fetched&.match(%r{^\/}) && fetched&.match(%r{\/$}) # A regex
           regexify(fetched)
         else
           fetched
@@ -158,14 +159,19 @@ module Faker
         # Super-simple fallback -- fallback to en if the
         # translation was missing.  If the translation isn't
         # in en either, then it will raise again.
-        I18n.translate(*args.push(opts))
+        disable_enforce_available_locales do
+          I18n.translate(*args.push(opts))
+        end
       end
 
       # Executes block with given locale set.
       def with_locale(tmp_locale = nil)
         current_locale = Faker::Config.own_locale
         Faker::Config.locale = tmp_locale
-        I18n.with_locale(tmp_locale) { yield }
+
+        disable_enforce_available_locales do
+          I18n.with_locale(tmp_locale) { yield }
+        end
       ensure
         Faker::Config.locale = current_locale
       end
@@ -199,6 +205,16 @@ module Faker
         rand(from..to)
       end
 
+      # If an array or range is passed, a random value will be selected.
+      # All other values are simply returned.
+      def resolve(value)
+        case value
+        when Array then sample(value)
+        when Range then rand value
+        else value
+        end
+      end
+
       def unique(max_retries = 10_000)
         @unique ||= UniqueGenerator.new(self, max_retries)
       end
@@ -214,20 +230,23 @@ module Faker
       def rand(max = nil)
         if max.nil?
           Faker::Config.random.rand
-        elsif max.is_a?(Range) || max.to_i > 0
+        elsif max.is_a?(Range) || max.to_i.positive?
           Faker::Config.random.rand(max)
         else
           0
         end
       end
+
+      def disable_enforce_available_locales
+        old_enforce_available_locales = I18n.enforce_available_locales
+        I18n.enforce_available_locales = false
+        yield
+      ensure
+        I18n.enforce_available_locales = old_enforce_available_locales
+      end
     end
   end
 end
 
-Dir.glob(File.join(File.dirname(__FILE__), 'faker', '*.rb')).sort.each { |f| require f }
-
-require 'extensions/array'
-require 'extensions/symbol'
-
-require 'helpers/char'
-require 'helpers/unique_generator'
+# require faker objects
+Dir.glob(File.join(File.dirname(__FILE__), 'faker', '/**/*.rb')).sort.each { |file| require file }

data/lib/faker/blockchain/bitcoin.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'digest'
+require 'securerandom'
+
+module Faker
+  class Blockchain
+    class Bitcoin < Base
+      class << self
+        PROTOCOL_VERSIONS = {
+          main: 0,
+          testnet: 111
+        }.freeze
+
+        def address
+          address_for(:main)
+        end
+
+        def testnet_address
+          address_for(:testnet)
+        end
+
+        protected
+
+        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]
+          Faker::Base58.encode(packed + checksum)
+        end
+      end
+    end
+  end
+end

data/lib/faker/blockchain/ethereum.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Faker
+  class Blockchain
+    class Ethereum < Base
+      class << self
+        def address
+          hex_alphabet = '0123456789abcdef'
+          var = +'0x'
+          40.times { var << sample(shuffle(hex_alphabet.split(''))) }
+          var
+        end
+      end
+    end
+  end
+end

data/lib/faker/blockchain/tezos.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'digest'
+require 'securerandom'
+
+module Faker
+  class Blockchain
+    class Tezos < Base
+      class << self
+        PREFIXES = {
+          tz1:    [6, 161, 159],
+          KT1:    [2, 90, 121],
+          edpk:   [13, 15, 37, 217],
+          edsk:  [13, 15, 58, 7],
+          edsig:  [9, 245, 205, 134, 18],
+          o:      [5, 116]
+        }.freeze
+
+        def account
+          encode_tz(:tz1, 20)
+        end
+
+        def contract
+          encode_tz(:KT1, 20)
+        end
+
+        def operation
+          encode_tz(:o, 32)
+        end
+
+        def signature
+          encode_tz(:edsig, 64)
+        end
+
+        protected
+
+        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]
+          Faker::Base58.encode(packed + checksum)
+        end
+      end
+    end
+  end
+end

data/lib/faker/{book.rb → books/book.rb}

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Faker
   class Book < Base
     flexible :book

data/lib/faker/books/culture_series.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Faker
+  class Books
+    class CultureSeries < Base
+      flexible :culture_series
+      class << self
+        def book
+          fetch('culture_series.books')
+        end
+
+        def culture_ship
+          fetch('culture_series.culture_ships')
+        end
+
+        def culture_ship_class
+          fetch('culture_series.culture_ship_classes')
+        end
+
+        def culture_ship_class_abv
+          fetch('culture_series.culture_ship_class_abvs')
+        end
+
+        def civ
+          fetch('culture_series.civs')
+        end
+
+        def planet
+          fetch('culture_series.planets')
+        end
+      end
+    end
+  end
+end

data/lib/faker/books/dune.rb

@@ -0,0 +1,58 @@
+# 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(character = nil)
+          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(source = nil)
+          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,73 @@
+# frozen_string_literal: true
+
+module Faker
+  class Books
+    class Lovecraft < Base
+      class << self
+        def location
+          fetch('lovecraft.location')
+        end
+
+        def fhtagn(number_of = 1)
+          Array.new(number_of) { fetch('lovecraft.fhtagn') }.join('. ')
+        end
+
+        def deity
+          fetch('lovecraft.deity')
+        end
+
+        def tome
+          fetch('lovecraft.tome')
+        end
+
+        def sentence(word_count = 4, random_words_to_add = 6)
+          words(word_count + rand(random_words_to_add.to_i).to_i, true).join(' ').capitalize + '.'
+        end
+
+        def word
+          random_word = sample(translate('faker.lovecraft.words'))
+          random_word =~ /\s/ ? word : random_word
+        end
+
+        def words(num = 3, spaces_allowed = false)
+          resolved_num = resolve(num)
+          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(sentence_count = 3)
+          [].tap do |sentences|
+            1.upto(resolve(sentence_count)) do
+              sentences << sentence(3)
+            end
+          end
+        end
+
+        def paragraph(sentence_count = 3, random_sentences_to_add = 3)
+          sentences(resolve(sentence_count) + rand(random_sentences_to_add.to_i).to_i).join(' ')
+        end
+
+        def paragraphs(paragraph_count = 3)
+          [].tap do |paragraphs|
+            1.upto(resolve(paragraph_count)) do
+              paragraphs << paragraph(3)
+            end
+          end
+        end
+
+        def paragraph_by_chars(chars = 256)
+          paragraph = paragraph(3)
+
+          paragraph += ' ' + paragraph(3) while paragraph.length < chars
+
+          paragraph[0...chars - 1] + '.'
+        end
+      end
+    end
+  end
+end

data/lib/faker/creature/animal.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Faker
+  module 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
+  module 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
+  module 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