faker 0.9.5 → 1.0.0

data/History.txt

@@ -1,3 +1,30 @@
+== 1.0.0 2011-09-05
+* 2 major enhancements
+  * Moved all formats to locale files
+  * Stopped interfering with I18n's global settings for fallbacks
+* 3 minor bug fixes:
+  * Ruby 1.9.2 fixes [eMxyzptlk]
+  * UTF8 fixes [maxmiliano]
+  * Updated IPv4 generator to return valid addresses [Sylvain Desbureaux]
+* Many minor enhancements:
+  * Added bork locale for bork-ified lorem [johnbentcope]
+  * Added IPv6 address generator [jc00ke]
+  * Removed deprecation warnings for Array#rand [chrismarshall]
+  * Added German translation and I18n improvments [Matthias Kühnert]
+  * Added Dutch translation [moretea]
+  * Added Lat/Long generator [Andy Callaghan]
+  * Added buzzword-laden title generator [supercleanse]
+  * Added optional extended wordlist for lorem [chriskottom]
+  * Updated German translation [Jan Schwenzien]
+  * Locale improvements [suweller]
+  * Added limit to lorem generator [darrenterhune]
+  * Added Brazilian Portuguese translation [maxmiliano]
+  * Added Australian translation [madeindata]
+  * Added Canadian translation [igbanam]
+  * Added Norwegian translation [kytrinyx]
+  * Lots of translation-related cleanup [kytrinyx]
+  
+
 == 0.9.5 2011-01-27
 * 1 minor bug fix:
   * Fixed YAML [Aaron Patterson]

data/README.md

@@ -13,19 +13,6 @@ Usage
 * Faker::Name.name => "Christophe Bartell"
 * Faker::Internet.email => "kirsten.greenholt@corkeryfisher.info"
 
-Usage with Rails
-----------------
-
-If you want to change your locale with Rails from the default of :en, change
-config/application.rb, setting config.i18n.locale to whatever locale you
-want.  Change locale rather than default_locale (as suggested by the comments
-in that file) so that I18n's fallbacks will work properly and Faker can use
-the formats and data in en.yml (if there is no Faker localization for your
-locale).  If you'd prefer to set default_locale rather than locale, then
-you'll also need to add config.i18n.fallbacks.defaults = [:en] to your
-configuration to make the fallbacks work for Faker.
-
-
 Customization
 ------------
 Since you may want to make addresses and other types of data look different

data/lib/extensions/array.rb

@@ -1,5 +1,7 @@
 class Array
-  def rand
-    self[Kernel.rand(length)]
+  unless self.method_defined? :sample
+    def sample
+      choice
+    end
   end
-end
+end

data/lib/faker.rb

@@ -1,4 +1,4 @@
-mydir = File.dirname(__FILE__)
+mydir = File.expand_path(File.dirname(__FILE__))
 
 begin
   require 'psych'
@@ -6,36 +6,82 @@ rescue LoadError
 end
 
 require 'i18n'
-I18n::Backend::Simple.send(:include, I18n::Backend::Fallbacks)
 I18n.load_path += Dir[File.join(mydir, 'locales', '*.yml')]
+I18n.reload!
 
 
 module Faker
   class Config
-    def self.locale=(locale)
-      I18n.locale = locale
+    @locale = nil
+
+    class << self
+      attr_writer :locale
+      def locale
+        @locale || I18n.locale
+      end
     end
   end
   
   class Base
     class << self
+      ## make sure numerify results doesn’t start with a zero
       def numerify(number_string)
-        number_string.gsub(/#/) { rand(10).to_s }
+        number_string.sub(/#/) { (rand(9)+1).to_s }.gsub(/#/) { rand(10).to_s }
       end
   
       def letterify(letter_string)
-        letter_string.gsub(/\?/) { ('a'..'z').to_a.rand }
+        letter_string.gsub(/\?/) { ('A'..'Z').to_a.sample }
       end
   
       def bothify(string)
         letterify(numerify(string))
       end
       
-      # Helper for the common approach of grabbing a translation with an array
-      # of values and selecting one of them
+      # Helper for the common approach of grabbing a translation
+      # with an array of values and selecting one of them.
       def fetch(key)
-        I18n.translate("faker.#{key}").rand
+        translate("faker.#{key}").sample
+      end
+      
+      # Load formatted strings from the locale, "parsing" them
+      # into method calls that can be used to generate a
+      # formatted translation: e.g., "#{first_name} #{last_name}".
+      def parse(key)
+        fetch(key).scan(/#\{([A-Za-z]+\.)?([^\}]+)\}([^#]+)?/).map {|kls, meth, etc| (kls ? Faker.const_get(kls.chop) : self).send(meth) + etc.to_s }.join
+      end
+      
+      # Call I18n.translate with our configured locale if no
+      # locale is specified
+      def translate(*args)
+        opts = args.last.is_a?(Hash) ? args.pop : {}
+        opts[:locale] ||= Faker::Config.locale
+        opts[:throw] = true
+        I18n.translate(*(args.push(opts)))
+      rescue
+        # 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.merge(:locale => :en))))
+      end
+      
+      def flexible(key)
+        @flexible_key = key
       end
+
+      # You can add whatever you want to the locale file, and it will get caught here.
+      # E.g., in your locale file, create a
+      #   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)
+        # Use the alternate form of translate to get a nil rather than a "missing translation" string
+        if translation = translate(:faker)[@flexible_key][m]
+          translation.respond_to?(:sample) ? translation.sample : translation
+        else
+          super
+        end
+      end
+
     end
   end
 end

data/lib/faker/address.rb

@@ -1,24 +1,18 @@
 module Faker
   class Address < Base
+    flexible :address
+
     class << self
       def city
-        [
-          '%s %s%s' % [city_prefix, Name.first_name, city_suffix],
-          '%s %s' % [city_prefix, Name.first_name],
-          '%s%s' % [Name.first_name, city_suffix],
-          '%s%s' % [Name.last_name, city_suffix],
-        ].rand
+        parse('address.city')
       end
 
       def street_name
-        [
-          Proc.new { [Name.last_name, street_suffix].join(' ') },
-          Proc.new { [Name.first_name, street_suffix].join(' ') }
-        ].rand.call
+        parse('address.street_name')
       end
 
       def street_address(include_secondary = false)
-        numerify("#{fetch('address.street_address')} #{street_name}#{' ' + secondary_address if include_secondary}")
+        numerify(parse('address.street_address') + (include_secondary ? ' ' + secondary_address : ''))
       end
 
       def secondary_address
@@ -26,7 +20,7 @@ module Faker
       end
 
       def zip_code
-        bothify(fetch('address.postcode')).upcase
+        bothify(fetch('address.postcode'))
       end
       alias_method :zip, :zip_code
       alias_method :postcode, :zip_code
@@ -38,18 +32,14 @@ module Faker
       def state;         fetch('address.state');         end
       def country;       fetch('address.country');       end
 
-      # You can add whatever you want to the locale file, and it will get 
-      # caught here... e.g., create a country_code array in your locale, 
-      # then you can call #country_code and it will act like #country
-      def method_missing(m, *args, &block)
-        # Use the alternate form of translate to get a nil rather than a "missing translation" string
-        if translation = I18n.translate(:faker)[:address][m]
-          translation.respond_to?(:rand) ? translation.rand : translation
-        else
-          super
-        end
+      def latitude
+        ((rand * 180) - 90).to_s
       end
-      
+
+      def longitude
+        ((rand * 360) - 180).to_s
+      end
+
       # Deprecated
       alias_method :earth_country, :country
       alias_method :us_state, :state
@@ -59,4 +49,4 @@ module Faker
 
     end
   end
-end
+end

data/lib/faker/company.rb

@@ -1,8 +1,10 @@
 module Faker
   class Company < Base
+    flexible :company
+
     class << self
       def name
-        Formats.rand.call
+        parse('company.name')
       end
     
       def suffix
@@ -10,30 +12,15 @@ module Faker
       end
       
       # Generate a buzzword-laden catch phrase.
-      # Wordlist from http://www.1728.com/buzzword.htm
       def catch_phrase
-        [
-          ["Adaptive", "Advanced", "Ameliorated", "Assimilated", "Automated", "Balanced", "Business-focused", "Centralized", "Cloned", "Compatible", "Configurable", "Cross-group", "Cross-platform", "Customer-focused", "Customizable", "Decentralized", "De-engineered", "Devolved", "Digitized", "Distributed", "Diverse", "Down-sized", "Enhanced", "Enterprise-wide", "Ergonomic", "Exclusive", "Expanded", "Extended", "Face to face", "Focused", "Front-line", "Fully-configurable", "Function-based", "Fundamental", "Future-proofed", "Grass-roots", "Horizontal", "Implemented", "Innovative", "Integrated", "Intuitive", "Inverse", "Managed", "Mandatory", "Monitored", "Multi-channelled", "Multi-lateral", "Multi-layered", "Multi-tiered", "Networked", "Object-based", "Open-architected", "Open-source", "Operative", "Optimized", "Optional", "Organic", "Organized", "Persevering", "Persistent", "Phased", "Polarised", "Pre-emptive", "Proactive", "Profit-focused", "Profound", "Programmable", "Progressive", "Public-key", "Quality-focused", "Reactive", "Realigned", "Re-contextualized", "Re-engineered", "Reduced", "Reverse-engineered", "Right-sized", "Robust", "Seamless", "Secured", "Self-enabling", "Sharable", "Stand-alone", "Streamlined", "Switchable", "Synchronised", "Synergistic", "Synergized", "Team-oriented", "Total", "Triple-buffered", "Universal", "Up-sized", "Upgradable", "User-centric", "User-friendly", "Versatile", "Virtual", "Visionary", "Vision-oriented"].rand, 
-          ["24 hour", "24/7", "3rd generation", "4th generation", "5th generation", "6th generation", "actuating", "analyzing", "assymetric", "asynchronous", "attitude-oriented", "background", "bandwidth-monitored", "bi-directional", "bifurcated", "bottom-line", "clear-thinking", "client-driven", "client-server", "coherent", "cohesive", "composite", "context-sensitive", "contextually-based", "content-based", "dedicated", "demand-driven", "didactic", "directional", "discrete", "disintermediate", "dynamic", "eco-centric", "empowering", "encompassing", "even-keeled", "executive", "explicit", "exuding", "fault-tolerant", "foreground", "fresh-thinking", "full-range", "global", "grid-enabled", "heuristic", "high-level", "holistic", "homogeneous", "human-resource", "hybrid", "impactful", "incremental", "intangible", "interactive", "intermediate", "leading edge", "local", "logistical", "maximized", "methodical", "mission-critical", "mobile", "modular", "motivating", "multimedia", "multi-state", "multi-tasking", "national", "needs-based", "neutral", "next generation", "non-volatile", "object-oriented", "optimal", "optimizing", "radical", "real-time", "reciprocal", "regional", "responsive", "scalable", "secondary", "solution-oriented", "stable", "static", "systematic", "systemic", "system-worthy", "tangible", "tertiary", "transitional", "uniform", "upward-trending", "user-facing", "value-added", "web-enabled", "well-modulated", "zero administration", "zero defect", "zero tolerance"].rand,
-          ["ability", "access", "adapter", "algorithm", "alliance", "analyzer", "application", "approach", "architecture", "archive", "artificial intelligence", "array", "attitude", "benchmark", "budgetary management", "capability", "capacity", "challenge", "circuit", "collaboration", "complexity", "concept", "conglomeration", "contingency", "core", "customer loyalty", "database", "data-warehouse", "definition", "emulation", "encoding", "encryption", "extranet", "firmware", "flexibility", "focus group", "forecast", "frame", "framework", "function", "functionalities", "Graphic Interface", "groupware", "Graphical User Interface", "hardware", "help-desk", "hierarchy", "hub", "implementation", "info-mediaries", "infrastructure", "initiative", "installation", "instruction set", "interface", "internet solution", "intranet", "knowledge user", "knowledge base", "local area network", "leverage", "matrices", "matrix", "methodology", "middleware", "migration", "model", "moderator", "monitoring", "moratorium", "neural-net", "open architecture", "open system", "orchestration", "paradigm", "parallelism", "policy", "portal", "pricing structure", "process improvement", "product", "productivity", "project", "projection", "protocol", "secured line", "service-desk", "software", "solution", "standardization", "strategy", "structure", "success", "superstructure", "support", "synergy", "system engine", "task-force", "throughput", "time-frame", "toolset", "utilisation", "website", "workforce"].rand
-        ].join(' ')
+        translate('faker.company.buzzwords').collect {|list| list.sample }.join(' ')
       end
       
       # When a straight answer won't do, BS to the rescue!
-      # Wordlist from http://dack.com/web/bullshit.html
       def bs
-        [
-          ["implement", "utilize", "integrate", "streamline", "optimize", "evolve", "transform", "embrace", "enable", "orchestrate", "leverage", "reinvent", "aggregate", "architect", "enhance", "incentivize", "morph", "empower", "envisioneer", "monetize", "harness", "facilitate", "seize", "disintermediate", "synergize", "strategize", "deploy", "brand", "grow", "target", "syndicate", "synthesize", "deliver", "mesh", "incubate", "engage", "maximize", "benchmark", "expedite", "reintermediate", "whiteboard", "visualize", "repurpose", "innovate", "scale", "unleash", "drive", "extend", "engineer", "revolutionize", "generate", "exploit", "transition", "e-enable", "iterate", "cultivate", "matrix", "productize", "redefine", "recontextualize"].rand,
-          ["clicks-and-mortar", "value-added", "vertical", "proactive", "robust", "revolutionary", "scalable", "leading-edge", "innovative", "intuitive", "strategic", "e-business", "mission-critical", "sticky", "one-to-one", "24/7", "end-to-end", "global", "B2B", "B2C", "granular", "frictionless", "virtual", "viral", "dynamic", "24/365", "best-of-breed", "killer", "magnetic", "bleeding-edge", "web-enabled", "interactive", "dot-com", "sexy", "back-end", "real-time", "efficient", "front-end", "distributed", "seamless", "extensible", "turn-key", "world-class", "open-source", "cross-platform", "cross-media", "synergistic", "bricks-and-clicks", "out-of-the-box", "enterprise", "integrated", "impactful", "wireless", "transparent", "next-generation", "cutting-edge", "user-centric", "visionary", "customized", "ubiquitous", "plug-and-play", "collaborative", "compelling", "holistic", "rich"].rand,
-          ["synergies", "web-readiness", "paradigms", "markets", "partnerships", "infrastructures", "platforms", "initiatives", "channels", "eyeballs", "communities", "ROI", "solutions", "e-tailers", "e-services", "action-items", "portals", "niches", "technologies", "content", "vortals", "supply-chains", "convergence", "relationships", "architectures", "interfaces", "e-markets", "e-commerce", "systems", "bandwidth", "infomediaries", "models", "mindshare", "deliverables", "users", "schemas", "networks", "applications", "metrics", "e-business", "functionalities", "experiences", "web services", "methodologies"].rand
-        ].join(' ')
+        translate('faker.company.bs').collect {|list| list.sample }.join(' ')
       end
     end
     
-    Formats = [
-      Proc.new { [ Name.last_name, suffix ].join(' ') },
-      Proc.new { [ Name.last_name, Name.last_name ].join('-') },
-      Proc.new { "%s, %s and %s" % [ Name.last_name, Name.last_name, Name.last_name ] }
-      ]
   end
-end
+end

data/lib/faker/internet.rb

@@ -1,3 +1,4 @@
+# encoding: utf-8
 module Faker
   class Internet < Base
     class << self
@@ -10,19 +11,30 @@ module Faker
       end
       
       def user_name(name = nil)
-        return name.scan(/\w+/).shuffle.join(%w(. _).rand).downcase if name
+        return name.scan(/\w+/).shuffle.join(%w(. _).sample).downcase if name
         
-        [ 
+        fix_umlauts([ 
           Proc.new { Name.first_name.gsub(/\W/, '').downcase },
           Proc.new { 
             [ Name.first_name, Name.last_name ].map {|n| 
               n.gsub(/\W/, '')
-            }.join(%w(. _).rand).downcase }
-        ].rand.call
+            }.join(%w(. _).sample).downcase }
+        ].sample.call)
       end
       
       def domain_name
-        [ domain_word, domain_suffix ].join('.')
+        [ fix_umlauts(domain_word), domain_suffix ].join('.')
+      end
+      
+      def fix_umlauts(string)
+        string.gsub(/[äöüß]/i) do |match|
+            case match.downcase
+                when "ä" 'ae'
+                when "ö" 'oe'
+                when "ü" 'ue'
+                when "ß" 'ss'
+            end
+        end
       end
       
       def domain_word
@@ -34,11 +46,22 @@ module Faker
       end
       
       def ip_v4_address
-        [(0..255).to_a.rand,
-        (0..255).to_a.rand,
-        (0..255).to_a.rand,
-        (0..255).to_a.rand].join('.')
+        ary = (2..254).to_a
+        [ary.sample,
+        ary.sample,
+        ary.sample,
+        ary.sample].join('.')
+      end
+
+      def ip_v6_address
+        @@ip_v6_space ||= (0..65535).to_a
+        container = (1..8).map{ |_| @@ip_v6_space.sample }
+        container.map{ |n| n.to_s(16) }.join(':')
+      end
+      
+      def url
+        "http://#{domain_name}/#{user_name}"
       end
     end
   end
-end
+end

data/lib/faker/lorem.rb

@@ -1,32 +1,39 @@
 module Faker
   # Based on Perl's Text::Lorem
   class Lorem < Base
-    def self.words(num = 3)
-      I18n.translate('faker.lorem.words').shuffle[0, num]
+    def self.words(num = 3, supplemental = false)
+      (
+        translate('faker.lorem.words') + 
+        (supplemental ? translate('faker.lorem.supplemental') : [])
+      ).shuffle[0, num]
+    end
+    
+    def self.characters(char_count = 255)
+      rand(36**char_count).to_s(36)
     end
 
-    def self.sentence(word_count = 4)
-      words(word_count + rand(6)).join(' ').capitalize + '.'
+    def self.sentence(word_count = 4, supplemental = false)
+      words(word_count + rand(6), supplemental).join(' ').capitalize + '.'
     end
 
-    def self.sentences(sentence_count = 3)
+    def self.sentences(sentence_count = 3, supplemental = false)
       [].tap do |sentences|
         1.upto(sentence_count) do
-          sentences << sentence
+          sentences << sentence(3, supplemental)
         end
       end
     end
 
-    def self.paragraph(sentence_count = 3)
-      sentences(sentence_count + rand(3)).join(' ')
+    def self.paragraph(sentence_count = 3, supplemental = false)
+      sentences(sentence_count + rand(3), supplemental).join(' ')
     end
 
-    def self.paragraphs(paragraph_count = 3)
+    def self.paragraphs(paragraph_count = 3, supplemental = false)
       [].tap do |paragraphs|
         1.upto(paragraph_count) do
-          paragraphs << paragraph
+          paragraphs << paragraph(3, supplemental)
         end
       end
     end
   end
-end
+end

data/lib/faker/name.rb

@@ -1,9 +1,11 @@
 module Faker
   class Name < Base
+    flexible :name
+
     class << self
       
       def name
-        fetch('name.formats').collect {|meth| self.send(meth) }.join(' ')
+        parse('name.name')
       end
       
       def first_name; fetch('name.first_name'); end
@@ -11,6 +13,10 @@ module Faker
       def prefix;     fetch('name.prefix'); end
       def suffix;     fetch('name.suffix'); end
       
+      # Generate a buzzword-laden job title
+      # Wordlist from http://www.bullshitjob.com/title/
+      def title; fetch('name.title.descriptor') + ' ' + fetch('name.title.level') + ' ' + fetch('name.title.job'); end
+      
     end
   end
-end
+end

data/lib/faker/phone_number.rb

@@ -4,6 +4,14 @@ module Faker
       def phone_number
         numerify(fetch('phone_number.formats'))
       end
+
+      def cell_phone
+        if (translation = translate(:faker)[:cell_phone]).is_a? Hash
+          numerify(translation[:formats].sample)
+        else
+          numerify(fetch('phone_number.formats'))
+        end
+      end
     end
   end
-end
+end

data/lib/faker/version.rb

@@ -1,3 +1,3 @@
 module Faker #:nodoc:
-  VERSION = "0.9.5"
+  VERSION = "1.0.0"
 end

data/lib/locales/de-ch.yml

@@ -3,9 +3,16 @@ de-ch:
     address:
       country_code: [CH, CH, CH, DE, AT, US, LI, US, HK, VN]
       postcode: ['1###', '2###', '3###', '4###', '5###', '6###', '7###', '8###', '9###']
+
     company:
       suffix: [AG, GmbH, und Söhne, und Partner, "& Co.", Gruppe, LLC, Inc.]
+      name:
+        - "#{Name.last_name} #{suffix}"
+        - "#{Name.last_name}-#{Name.last_name}"
+        - "#{Name.last_name}, #{Name.last_name} und #{Name.last_name}"
+
     internet:
       domain_suffix: [com, net, biz, ch, de, li, at, ch, ch]
+
     phone_number:
       formats: ['0800 ### ###', '0800 ## ## ##', '0## ### ## ##', '0## ### ## ##', '+41 ## ### ## ##', '0900 ### ###', '076 ### ## ##', '+4178 ### ## ##', '0041 79 ### ## ##']