faker 1.8.7 → 2.17.0

data/bin/faker

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+lib_path = File.expand_path('../lib', __dir__)
+$LOAD_PATH.unshift(lib_path) unless $LOAD_PATH.include?(lib_path)

data/lib/faker.rb

@@ -1,32 +1,27 @@
-# -*- coding: utf-8 -*-
-mydir = File.expand_path(File.dirname(__FILE__))
+# frozen_string_literal: true
 
-begin
-  require 'psych'
-rescue LoadError
-end
+mydir = __dir__
 
+require 'psych'
 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
+Dir.glob(File.join(mydir, 'helpers', '*.rb')).sort.each { |file| require file }
+
 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
-        @locale || I18n.locale
+        # Because I18n.locale defaults to :en, if we don't have :en in our available_locales, errors will happen
+        @locale || (I18n.available_locales.include?(I18n.locale) ? I18n.locale : I18n.available_locales.first)
       end
 
       def own_locale
@@ -34,7 +29,7 @@ module Faker
       end
 
       def random
-        @random || Random::DEFAULT
+        @random || Random.new
       end
     end
   end
@@ -42,12 +37,17 @@ module Faker
   class Base
     Numbers = Array(0..9)
     ULetters = Array('A'..'Z')
-    Letters = ULetters + Array('a'..'z')
+    LLetters = Array('a'..'z')
+    Letters = ULetters + LLetters
 
     class << self
-      ## make sure numerify results doesn’t start with a zero
-      def numerify(number_string)
-        number_string.sub(/#/) { (rand(9)+1).to_s }.gsub(/#/) { rand(10).to_s }
+      NOT_GIVEN = Object.new
+
+      ## 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
 
       def letterify(letter_string)
@@ -77,26 +77,26 @@ module Faker
       #
       # "U3V  3TP"
       #
-      def regexify(re)
-        re = re.source if re.respond_to?(:source) # Handle either a Regexp or a String that looks like a Regexp
-        re.
-          gsub(/^\/?\^?/, '').gsub(/\$?\/?$/, '').                                                                      # Ditch the anchors
-          gsub(/\{(\d+)\}/, '{\1,\1}').gsub(/\?/, '{0,1}').                                                             # All {2} become {2,2} and ? become {0,1}
-          gsub(/(\[[^\]]+\])\{(\d+),(\d+)\}/) {|match| $1 * sample(Array(Range.new($2.to_i, $3.to_i))) }.                # [12]{1,2} becomes [12] or [12][12]
-          gsub(/(\([^\)]+\))\{(\d+),(\d+)\}/) {|match| $1 * sample(Array(Range.new($2.to_i, $3.to_i))) }.                # (12|34){1,2} becomes (12|34) or (12|34)(12|34)
-          gsub(/(\\?.)\{(\d+),(\d+)\}/) {|match| $1 * sample(Array(Range.new($2.to_i, $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($1.split('')) }.                                                          # All [ABC] become B (or A or C)
-          gsub('\d') {|match| sample(Numbers) }.
-          gsub('\w') {|match| sample(Letters) }
+      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(/\{(\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))) }                      # 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(Regexp.last_match(1).split('')) } # All [ABC] become B (or A or C)
+          .gsub('\d') { |_match| sample(Numbers) }
+          .gsub('\w') { |_match| sample(Letters) }
       end
 
       # Helper for the common approach of grabbing a translation
       # with an array of values and selecting one of them.
       def fetch(key)
         fetched = sample(translate("faker.#{key}"))
-        if fetched && fetched.match(/^\//) and fetched.match(/\/$/) # A regex
+        if fetched&.match(%r{^/}) && fetched&.match(%r{/$}) # A regex
           regexify(fetched)
         else
           fetched
@@ -108,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(/^\//) and fetched.match(/\/$/) # A regex
+        if !fetched.respond_to?(:sample) && fetched.match(%r{^/}) && fetched.match(%r{/$}) # A regex
           regexify(fetched)
         else
           fetched
@@ -120,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 {|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
@@ -129,39 +129,48 @@ module Faker
           # In either case the information will be retained for reconstruction of the string.
           text = prefix
 
-          # If the class has the method, call it, otherwise
-          # fetch the transation (i.e., faker.name.first_name)
-          text += cls.respond_to?(meth) ? cls.send(meth) : fetch("#{(kls || self).to_s.split('::').last.downcase}.#{meth.downcase}")
+          # If the class has the method, call it, otherwise fetch the translation
+          # (e.g., faker.phone_number.area_code)
+          text += if cls.respond_to?(meth)
+                    cls.send(meth)
+                  else
+                    # Do just enough snake casing to convert PhoneNumber to phone_number
+                    key_path = cls.to_s.split('::').last.gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase
+                    fetch("#{key_path}.#{meth.downcase}")
+                  end
 
           # And tack on spaces, commas, etc. left over in the string
-          text += etc.to_s
-        }
+          text + etc.to_s
+        end
         # If the fetched key couldn't be parsed, then fallback to numerify
         parts.any? ? parts.join : numerify(fetched)
       end
 
       # Call I18n.translate with our configured locale if no
       # locale is specified
-      def translate(*args)
-        opts = args.last.is_a?(Hash) ? args.pop : {}
+      def translate(*args, **opts)
         opts[:locale] ||= Faker::Config.locale
         opts[:raise] = true
-        I18n.translate(*(args.push(opts)))
+        I18n.translate(*args, **opts)
       rescue I18n::MissingTranslationData
-        opts = args.last.is_a?(Hash) ? args.pop : {}
         opts[:locale] = :en
 
         # 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, **opts)
+        end
       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
-        I18n.with_locale(tmp_locale) { yield }
+
+        disable_enforce_available_locales do
+          I18n.with_locale(tmp_locale, &block)
+        end
       ensure
         Faker::Config.locale = current_locale
       end
@@ -175,29 +184,54 @@ module Faker
       #   name:
       #     girls_name: ["Alice", "Cheryl", "Tatiana"]
       # Then you can call Faker::Name.girls_name and it will act like #first_name
-      def method_missing(m, *args, &block)
+      def method_missing(mth, *args, &block)
         super unless @flexible_key
 
-        # Use the alternate form of translate to get a nil rather than a "missing translation" string
-        if translation = translate(:faker)[@flexible_key][m]
+        if (translation = translate("faker.#{@flexible_key}.#{mth}"))
           sample(translation)
         else
           super
         end
       end
 
+      def respond_to_missing?(method_name, include_private = false)
+        super
+      end
+
       # Generates a random value between the interval
       def rand_in_range(from, to)
         from, to = to, from if to < from
         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
+
+      # Return unique values from the generator every time.
+      #
+      # @param max_retries [Integer] The max number of retries that should be done before giving up.
+      # @return [self]
       def unique(max_retries = 10_000)
-        @unique_generator ||= UniqueGenerator.new(self, max_retries)
+        @unique ||= UniqueGenerator.new(self, max_retries)
       end
 
-      def sample(list)
-        list.respond_to?(:sample) ? list.sample(random: Faker::Config.random) : list
+      def sample(list, num = nil)
+        if list.respond_to?(:sample)
+          if num
+            list.sample(num, random: Faker::Config.random)
+          else
+            list.sample(random: Faker::Config.random)
+          end
+        else
+          list
+        end
       end
 
       def shuffle(list)
@@ -207,20 +241,75 @@ 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
+
+      private
+
+      def warn_for_deprecated_arguments
+        keywords = []
+        yield(keywords)
+
+        return if keywords.empty?
+
+        method_name = caller.first.match(/`(?<method_name>.*)'/)[:method_name]
+
+        keywords.each.with_index(1) do |keyword, index|
+          i = case index
+              when 1 then '1st'
+              when 2 then '2nd'
+              when 3 then '3rd'
+              else "#{index}th"
+              end
+
+          warn_with_uplevel(<<~MSG, uplevel: 5)
+            Passing `#{keyword}` with the #{i} argument of `#{method_name}` is deprecated. Use keyword argument like `#{method_name}(#{keyword}: ...)` instead.
+          MSG
+        end
+
+        warn(<<~MSG)
+
+          To automatically update from positional arguments to keyword arguments,
+          install rubocop-faker and run:
+
+          rubocop \\
+            --require rubocop-faker \\
+            --only Faker/DeprecatedArguments \\
+            --auto-correct
+
+        MSG
+      end
+
+      # Workaround for emulating `warn '...', uplevel: 1` in Ruby 2.4 or lower.
+      def warn_with_uplevel(message, uplevel: 1)
+        at = parse_caller(caller[uplevel]).join(':')
+        warn "#{at}: #{message}"
+      end
+
+      def parse_caller(at)
+        # rubocop:disable Style/GuardClause
+        if /^(.+?):(\d+)(?::in `.*')?/ =~ at
+          file = Regexp.last_match(1)
+          line = Regexp.last_match(2).to_i
+          [file, line]
+        end
+        # rubocop:enable Style/GuardClause
+      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(mydir, 'faker', '/**/*.rb')).sort.each { |file| require file }

data/lib/faker/blockchain/aeternity.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Faker
+  class Blockchain
+    class Aeternity < Base
+      class << self
+        ##
+        # Produces a random Aeternity wallet address
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::Blockchain::Aeternity.address
+        #     #=> "ak_zvU8YQLagjcfng7Tg8yCdiZ1rpiWNp1PBn3vtUs44utSvbJVR"
+        #
+        def address
+          "ak_#{rand_strings}"
+        end
+
+        ##
+        # Produces a random Aeternity transaction
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::Blockchain::Aeternity.transaction
+        #     #=> "th_147nDP22h3pHrLt2qykTH4txUwQh1ccaXp"
+        #
+        def transaction
+          "th_#{rand_strings(51)}"
+        end
+
+        ##
+        # Produces a random Aeternity contract
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::Blockchain::Aeternity.contract
+        #     #=> "ct_Hk2JsNeWGEYQEHHQCfcBeGrwbhtYSwFTPdDhW2SvjFYVojyhW"
+        #
+        def contract
+          "ct_#{rand_strings}"
+        end
+
+        ##
+        # Produces a random Aeternity oracle
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::Blockchain::Aeternity.oracle
+        #     #=> "ok_28QDg7fkF5qiKueSdUvUBtCYPJdmMEoS73CztzXCRAwMGKHKZh"
+        #
+        def oracle
+          "ok_#{rand_strings(51)}"
+        end
+
+        protected
+
+        def rand_strings(length = 50)
+          hex_alphabet = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
+          var = +''
+          length.times { var << sample(shuffle(hex_alphabet.split(''))) }
+          var
+        end
+      end
+    end
+  end
+end

data/lib/faker/blockchain/bitcoin.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'openssl'
+require 'securerandom'
+
+module Faker
+  class Blockchain
+    class Bitcoin < Base
+      class << self
+        # @private
+        PROTOCOL_VERSIONS = {
+          main: 0,
+          testnet: 111
+        }.freeze
+
+        ##
+        # Produces a Bitcoin wallet address
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::Blockchain::Bitcoin.address
+        #     #=> "147nDP22h3pHrLt2qykTH4txUwQh1ccaXp"
+        #
+        # @faker.version 1.9.2
+        def address
+          address_for(:main)
+        end
+
+        ##
+        # Produces a Bitcoin testnet address
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::Blockchain::Bitcoin.testnet_address
+        #     #=> "n4YjRyYD6V6zREpk6opqESDqD3KYnMdVEB"
+        #
+        # @faker.version 1.9.2
+        def testnet_address
+          address_for(:testnet)
+        end
+
+        protected
+
+        ##
+        # Generates a random Bitcoin address for the given network
+        #
+        # @param network [Symbol] The name of network protocol to generate an address for
+        # @return [String] A Bitcoin address
+        def address_for(network)
+          version = PROTOCOL_VERSIONS.fetch(network)
+          packed = version.chr + Faker::Config.random.bytes(20)
+          checksum = OpenSSL::Digest::SHA256.digest(OpenSSL::Digest::SHA256.digest(packed))[0..3]
+          Faker::Base58.encode(packed + checksum)
+        end
+      end
+    end
+  end
+end