faker 1.8.6 → 3.0.0

data/lib/faker.rb

@@ -1,40 +1,37 @@
-# -*- 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
-    @locale = nil
-    @random = nil
-
+  module Config
     class << self
-      attr_writer :locale
-      attr_writer :random
+      def locale=(new_locale)
+        Thread.current[:faker_config_locale] = new_locale
+      end
 
       def locale
-        @locale || I18n.locale
+        # Because I18n.locale defaults to :en, if we don't have :en in our available_locales, errors will happen
+        Thread.current[:faker_config_locale] || (I18n.available_locales.include?(I18n.locale) ? I18n.locale : I18n.available_locales.first)
       end
 
       def own_locale
-        @locale
+        Thread.current[:faker_config_locale]
+      end
+
+      def random=(new_random)
+        Thread.current[:faker_config_random] = new_random
       end
 
       def random
-        @random || Random::DEFAULT
+        Thread.current[:faker_config_random] || Random
       end
     end
   end
@@ -42,12 +39,19 @@ 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 }
+      attr_reader :flexible_key
+
+      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 +81,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).chars) } # 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 +112,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 +124,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 +133,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 +188,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)
-        super unless @flexible_key
+      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 +245,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(mydir, 'faker', '/**/*.rb')).sort.each { |file| require file }

data/lib/helpers/base58.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Faker
+  module Base58
+    def self.encode(str)
+      alphabet = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
+      base = alphabet.size
+
+      lv = 0
+      str.chars.reverse.each_with_index { |v, i| lv += v.unpack1('C') * 256**i }
+
+      ret = +''
+      while lv.positive?
+        lv, mod = lv.divmod(base)
+        ret << alphabet[mod]
+      end
+
+      npad = str.match(/^#{0.chr}*/)[0].to_s.size
+      '1' * npad + ret.reverse
+    end
+  end
+end

data/lib/helpers/char.rb

@@ -1,64 +1,60 @@
-# coding: utf-8
+# frozen_string_literal: true
+
 module Faker
   module Char
     def self.prepare(string)
       result = romanize_cyrillic string
       result = fix_umlauts result
-      result.gsub(/\W/, '').downcase
+      result.gsub(/[^\w-]/, '').downcase
     end
 
     def self.fix_umlauts(string)
       string.gsub(/[äöüß]/i) do |match|
         case match.downcase
-          when "ä" 'ae'
-          when "ö" 'oe'
-          when "ü" 'ue'
-          when "ß" 'ss'
+        when 'ä' then 'ae'
+        when 'ö' then 'oe'
+        when 'ü' then 'ue'
+        when 'ß' then 'ss'
+        else match.downcase
         end
       end
     end
 
     def self.romanize_cyrillic(string)
-      if Faker::Config.locale == "uk"
+      if Faker::Config.locale == 'uk'
         # Based on conventions abopted by BGN/PCGN for Ukrainian
         uk_chars = {
-          'а' => 'a',  'б' => 'b',  'в' => 'v',  'г' => 'h',  'ґ' => 'g',  'д' => 'd',
-          'е' => 'e',  'є' => 'ye', 'ж' => 'zh', 'з' => 'z',  'и' => 'y',  'і' => 'i',
-          'ї' => 'yi', 'й' => 'y',  'к' => 'k',  'л' => 'l',  'м' => 'm',  'н' => 'n',
-          'о' => 'o',  'п' => 'p',  'р' => 'r',  'с' => 's',  'т' => 't',  'у' => 'u',
-          'ф' => 'f',  'х' => 'kh', 'ц' => 'ts', 'ч' => 'ch', 'ш' => 'sh', 'щ' => 'shch',
-          'ю' => 'yu', 'я' => 'ya',
-          'А' => 'a',  'Б' => 'b',  'В' => 'v',  'Г' => 'h',  'Ґ' => 'g',  'Д' => 'd',
-          'Е' => 'e',  'Є' => 'ye', 'Ж' => 'zh', 'З' => 'z',  'И' => 'y',  'І' => 'i',
-          'Ї' => 'yi', 'Й' => 'y',  'К' => 'k',  'Л' => 'l',  'М' => 'm',  'Н' => 'n',
-          'О' => 'o',  'П' => 'p',  'Р' => 'r',  'С' => 's',  'Т' => 't',  'У' => 'u',
-          'Ф' => 'f',  'Х' => 'kh', 'Ц' => 'ts', 'Ч' => 'ch', 'Ш' => 'sh', 'Щ' => 'shch',
-          'Ю' => 'yu', 'Я' => 'ya',
-          'ь' => '' # Ignore symbol, because its standard presentation is not allowed in URLs
+          'а' => 'a', 'б' => 'b', 'в' => 'v', 'г' => 'h', 'ґ' => 'g', 'д' => 'd', 'е' => 'e',
+          'є' => 'ye', 'ж' => 'zh', 'з' => 'z', 'и' => 'y', 'і' => 'i', 'ї' => 'yi', 'й' => 'y',
+          'к' => 'k',  'л' => 'l', 'м' => 'm', 'н' => 'n', 'о' => 'o', 'п' => 'p', 'р' => 'r',
+          'с' => 's', 'т' => 't', 'у' => 'u', 'ф' => 'f', 'х' => 'kh', 'ц' => 'ts', 'ч' => 'ch',
+          'ш' => 'sh', 'щ' => 'shch', 'ю' => 'yu', 'я' => 'ya', 'А' => 'a', 'Б' => 'b', 'В' => 'v',
+          'Г' => 'h', 'Ґ' => 'g', 'Д' => 'd', 'Е' => 'e', 'Є' => 'ye', 'Ж' => 'zh', 'З' => 'z',
+          'И' => 'y', 'І' => 'i', 'Ї' => 'yi', 'Й' => 'y', 'К' => 'k', 'Л' => 'l', 'М' => 'm',
+          'Н' => 'n', 'О' => 'o', 'П' => 'p', 'Р' => 'r', 'С' => 's', 'Т' => 't', 'У' => 'u',
+          'Ф' => 'f', 'Х' => 'kh', 'Ц' => 'ts', 'Ч' => 'ch', 'Ш' => 'sh', 'Щ' => 'shch', 'Ю' => 'yu',
+          'Я' => 'ya', 'ь' => '' # Ignore symbol, because its standard presentation is not allowed in URLs
         }
         return string.gsub(/[а-яА-ЯіїєґІЇЄҐ]/, uk_chars)
       end
 
-      if Faker::Config.locale == "ru"
+      if Faker::Config.locale == 'ru'
         # Based on conventions abopted by BGN/PCGN for Russian
         ru_chars = {
-            'а' => 'a',  'б' => 'b',  'в' => 'v',    'г' => 'h',  'д' => 'd',  'е' => 'e',
-            'ё' => 'ye', 'ж' => 'zh', 'з' => 'z',    'и' => 'i',  'й' => 'y',  'к' => 'k',
-            'л' => 'l',  'м' => 'm',  'н' => 'n',    'о' => 'o',  'п' => 'p',  'р' => 'r',
-            'с' => 's',  'т' => 't',  'у' => 'u',    'ф' => 'f',  'х' => 'kh', 'ц' => 'ts',
-            'ч' => 'ch', 'ш' => 'sh', 'щ' => 'shch', 'ы' => 'у',  'э' => 'e',  'ю' => 'yu',
-            'я' => 'ya',
-            'А' => 'a',  'Б' => 'b',  'В' => 'v',    'Г' => 'h',  'Д' => 'd',  'Е' => 'e',
-            'Ё' => 'ye', 'Ж' => 'zh', 'З' => 'z',    'И' => 'i',  'Й' => 'y',  'К' => 'k',
-            'Л' => 'l',  'М' => 'm',  'Н' => 'n',    'О' => 'o',  'П' => 'p',  'Р' => 'r',
-            'С' => 's',  'Т' => 't',  'У' => 'u',    'Ф' => 'f',  'Х' => 'kh', 'Ц' => 'ts',
-            'Ч' => 'ch', 'Ш' => 'sh', 'Щ' => 'shch', 'Ы' => 'у',  'Э' => 'e',  'Ю' => 'yu',
-            'Я' => 'ya',
-            'ь' => '',   'ъ' => '' # Ignore symbols, because its standard presentation is not allowed in URLs
+          'а' => 'a', 'б' => 'b', 'в' => 'v', 'г' => 'h', 'д' => 'd', 'е' => 'e',
+          'ё' => 'ye', 'ж' => 'zh', 'з' => 'z', 'и' => 'i', 'й' => 'y', 'к' => 'k',
+          'л' => 'l',  'м' => 'm',  'н' => 'n',  'о' => 'o', 'п' => 'p', 'р' => 'r',
+          'с' => 's',  'т' => 't',  'у' => 'u',  'ф' => 'f', 'х' => 'kh', 'ц' => 'ts',
+          'ч' => 'ch', 'ш' => 'sh', 'щ' => 'shch', 'ы' => 'у', 'э' => 'e', 'ю' => 'yu',
+          'я' => 'ya', 'А' => 'a',  'Б' => 'b', 'В' => 'v', 'Г' => 'h', 'Д' => 'd',
+          'Е' => 'e', 'Ё' => 'ye', 'Ж' => 'zh', 'З' => 'z', 'И' => 'i', 'Й' => 'y',
+          'К' => 'k', 'Л' => 'l', 'М' => 'm', 'Н' => 'n', 'О' => 'o', 'П' => 'p', 'Р' => 'r',
+          'С' => 's',  'Т' => 't',  'У' => 'u', 'Ф' => 'f', 'Х' => 'kh', 'Ц' => 'ts',
+          'Ч' => 'ch', 'Ш' => 'sh', 'Щ' => 'shch', 'Ы' => 'у', 'Э' => 'e', 'Ю' => 'yu',
+          'Я' => 'ya', 'ь' => '', 'ъ' => '' # Ignore symbols, because its standard presentation is not allowed in URLs
         }
         return string.gsub(/[а-яА-Я]/, ru_chars)
       end
-
       string
     end
   end

data/lib/helpers/unique_generator.rb

@@ -1,32 +1,60 @@
+# frozen_string_literal: true
+
 module Faker
   class UniqueGenerator
     def initialize(generator, max_retries)
       @generator = generator
       @max_retries = max_retries
-      @previous_results = Hash.new { |hash, key| hash[key] = Set.new }
     end
 
     def method_missing(name, *arguments)
+      self.class.marked_unique.add(self)
+
       @max_retries.times do
         result = @generator.public_send(name, *arguments)
 
-        next if @previous_results[[name, arguments]].include?(result)
+        next if previous_results[[name, arguments]].include?(result)
 
-        @previous_results[[name, arguments]] << result
+        previous_results[[name, arguments]] << result
         return result
       end
 
-      raise RetryLimitExceeded
+      raise RetryLimitExceeded, "Retry limit exceeded for #{name}"
+    end
+    # Have method_missing use ruby 2.x keywords if the method exists.
+    # This is necessary because the syntax for passing arguments (`...`)
+    # is invalid on versions before Ruby 2.7, so it can't be used.
+    ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
+
+    def respond_to_missing?(method_name, include_private = false)
+      method_name.to_s.start_with?('faker_') || super
     end
 
     RetryLimitExceeded = Class.new(StandardError)
 
+    def previous_results
+      Thread.current[:faker_unique_generator_previous_results] ||= {}
+      Thread.current[:faker_unique_generator_previous_results][@generator] ||= Hash.new { |hash, key| hash[key] = Set.new }
+    end
+
     def clear
-      @previous_results.clear
+      previous_results.clear
+    end
+
+    def self.marked_unique
+      Thread.current[:faker_unique_generator_marked_unique] ||= Set.new
     end
 
     def self.clear
-      ObjectSpace.each_object(self, &:clear)
+      marked_unique.each(&:clear)
+      marked_unique.clear
+    end
+
+    def exclude(name, arguments, values)
+      values ||= []
+      values.each do |value|
+        previous_results[[name, arguments]] << value
+      end
     end
   end
 end

data/lib/locales/README.md

@@ -4,9 +4,8 @@ The default locale is English. You can see how it is implemented in the "transla
 
 Here's how to set it:
 
-```
+```ruby
 # Sets the locale to "Simplified Chinese":
-
 Faker::Config.locale = 'zh-CN'
 ```
 
@@ -14,21 +13,21 @@ It works so that once the Faker locale is set to a different location, the trans
 
 Using Chinese as an example, when the locale is set to Chinese and you attempt to call for hipster ipsem (which doesn't exist at the time of this writing), you will get English back. It checks the "zh-CH.yml" file, does not find "hipster" and then checks the "en.yml" file and returns a word from that array.
 
-```
+```ruby
 Faker::Config.locale = 'zh-CN'
-
 Faker::Hipster.word #=> "kogi"
 ```
 
 In order to update a locale with more translation features, simply add a new field to the .yml file that corresponds to an existing piece of functionality in the "en.yml" file. In this example, that would mean providing Chinese hipster words.
 
-```
+```yaml
 # /lib/locales/zh-CN.yml
+hipster:
+    - "屌丝"
+```
 
-hipster: ["屌丝"]
-
+```ruby
 # Now this should work:
-
 Faker::Hipster.word #=> "屌丝"
 ```
 
@@ -36,6 +35,6 @@ After you've done that, find or create a test file for the locale you've updated
 
 In our hypothetical example here, one would add something like this to the "test-zh-locale.rb" file in the "test_ch_methods" method:
 
-```
+```ruby
 assert Faker::Hipster.word.is_a? String
 ```