randomperson 0.0.19 → 1.0.0

data/lib/randomperson/generator.rb

@@ -1,28 +1,17 @@
 module RandomPerson
 
-  class Generator
+  module Generator
     
-    require_relative './choice.rb'
     require_relative './person.rb'
     
-    attr_reader :generators
-   
-    # Sets up a list of generators
+    # Build a demographic generator
+    # @param [RandomPerson::Demographic] demographic The demographic you would like.
     # @example 
-    #   g = RandomPerson::Generator.new
-    def initialize
-      @generators = [ ] 
-    end
-
-    
-    # Build a choice generator
-    # @param [RandomPerson::Choice] choice A Choice object.
-    # @example 
-    #   g.make_generator choice
-    def make_generator( choice )
+    #   Generator.make_generator demographic
+    def self.make_generator( demographic )
     f = -> {
-        g = Generator.pick_gender( choice.gender_ratio )
-        age = Generator.pick_age( choice.age_lower, choice.age_upper)
+        g = Generator.pick_gender( demographic.gender_ratio )
+        age = Generator.pick_age( demographic.age_lower, demographic.age_upper)
         
         person = Person.new(
           :gender =>  g, 
@@ -31,80 +20,68 @@ module RandomPerson
         )
         
         if person.gender == 'm'   
-          person.first = choice.malefirst.execute( person ) unless choice.malefirst.nil?
+          person.first = demographic.malefirst.execute( person ) unless demographic.malefirst.nil?
         else
-          person.first = choice.femalefirst.execute( person ) unless choice.femalefirst.nil?
+          person.first = demographic.femalefirst.execute( person ) unless demographic.femalefirst.nil?
         end
           
-        person.last = choice.last.execute( person ) unless choice.last.nil?#lastname, 
-        person.prefix = choice.prefix.execute( person ) unless choice.prefix.nil? #title 
-        person.suffix = choice.suffix.execute( person ) unless choice.suffix.nil?#suffix
+        person.last = demographic.last.execute( person ) unless demographic.last.nil? #lastname, 
+        person.prefix = demographic.prefix.execute( person ) unless demographic.prefix.nil? #title 
+        person.suffix = demographic.suffix.execute( person ) unless demographic.suffix.nil?#suffix
         
         person
       }
-      
-      @generators << f
+
+      f
     end
     
-    class << self
-    
-      #create a ratio that is made up of ranges
-      #to help hit with multiple valued ratios
-      def ratiod( ratio=[1,1] )
-        sum = ratio.reduce(:+) #sum
-        mult = 100.divmod( sum ).first #get a bigger spread of numbers
-        ratio.map! { |n| n * mult }
-        new_ratio = ratio.inject([0..0]) {|acc,n| acc + [acc.last.last ... (n + acc.last.last)] }
-        new_ratio.shift #get rid of 0..0
-        return new_ratio
-      end 
       
-      # Takes a ratio and uses this to randomly select either a male or a female. To get only males or only females, pass in a 0 for either gender to make sure of getting the other gender for definite.
-      # @example To only get males:
-      #   pick_gender( [1,0] )
-      # @example To only get females:
-      #   pick_gender( [0,1] )
-      # @example To be likely to get 2 females to every male:
-      #   pick_gender( [1,2] )
-      # @param [optional,Array<Integer,Integer>] ratio The ratio of males to females expressed in an array, e.g. [1,1] is (a chance of) one male for every female, [1,2] is one male to two females. The default is [1,1].
-      # @return [String] Returns a 'f' for female or an 'm' for male.
-      def pick_gender( ratio=[1,1] ) #male first
-        if ratio.length == 2
-          return 'f' if ratio.first == 0
-          return 'm' if ratio.last == 0 
-        end
-        rat = ratiod( ratio )
-        r = rand(rat.last.last)
-        case r
-          when rat[0] then 'm'
-          when rat[1] then 'f'
-        end
-      end
-
-      def pick_age( lower=0, upper=100 )
-        age =  rand(upper - lower).to_i + lower 
+    #create a ratio that is made up of ranges
+    #to help hit with multiple valued ratios
+    def self.ratiod( ratio=[1,1] )
+      sum = ratio.reduce(:+) #sum
+      mult = 100.divmod( sum ).first #get a bigger spread of numbers
+      ratio.map! { |n| n * mult }
+      new_ratio = ratio.inject([0..0]) {|acc,n| acc + [acc.last.last ... (n + acc.last.last)] }
+      new_ratio.shift #get rid of 0..0
+      return new_ratio
+    end 
+    
+    # Takes a ratio and uses this to randomly select either a male or a female. To get only males or only females, pass in a 0 for either gender to make sure of getting the other gender for definite.
+    # @example To only get males:
+    #   pick_gender( [1,0] )
+    # @example To only get females:
+    #   pick_gender( [0,1] )
+    # @example To be likely to get 2 females to every male:
+    #   pick_gender( [1,2] )
+    # @param [optional,Array<Integer,Integer>] ratio The ratio of males to females expressed in an array, e.g. [1,1] is (a chance of) one male for every female, [1,2] is one male to two females. The default is [1,1].
+    # @return [String] Returns a 'f' for female or an 'm' for male.
+    def self.pick_gender( ratio=[1,1] ) #male first
+      if ratio.length == 2
+        return 'f' if ratio.first == 0
+        return 'm' if ratio.last == 0 
       end
-      
-      def pick_dob( y=16 )
-        year  = Time.now.year - y
-        month = rand(12) + 1;
-        day   = rand( Date.days_in_month( year, month ) ) + 1 
-        Time.local( year, month, day )
+      rat = ratiod( ratio )
+      r = rand(rat.last.last)
+      case r
+        when rat[0] then 'm'
+        when rat[1] then 'f'
       end
-      
-    
-    end #class << self
-      
-    
-
-  
+    end
 
-    def reset
-      @generators = [ ] 
+    def self.pick_age( lower=0, upper=100 )
+      age =  rand(upper - lower).to_i + lower 
+    end
+    
+    def self.pick_dob( y=16 )
+      year  = Time.now.year - y
+      month = rand(12) + 1;
+      day   = rand( Date.days_in_month( year, month ) ) + 1 
+      Time.local( year, month, day )
     end
 
 
   
   end
 
-end
+end

data/lib/randomperson/name.rb

@@ -1,20 +1,25 @@
+# encoding: UTF-8
+
+require_relative "./Outputter.rb"
+
+
 module RandomPerson
 
   class Name
+    include Outputter
+    
+    attr_accessor :formats, :formats_ratiod, :names, :possibles
+
+    def initialize
+      @possibles = Hash[ @formats_ratiod.zip @formats ] if @possibles.nil? unless @formats_ratiod.nil?
+      
+      @on_execute ||= for_standard
+      
+      @possibles    
+    end
     
-    attr_accessor :formats, :formats_ratiod, :names
 
-    def execute( person=nil )
-      if @formats.length > 1
-        r = rand(@formats_ratiod.last.end)
-        i = @formats_ratiod.index_in_range( r )
-        f = @formats.by_index(i).last
-      else
-        k, f = @formats.first #throw away the key name
-      end
-      f.( @names )
-    end 
   
-  end
+  end # class
   
-end
+end # RandomPerson

data/lib/randomperson/person.rb

@@ -5,6 +5,8 @@ module RandomPerson
   
     attr_accessor :gender, :age, :dob, :first, :last, :prefix, :suffix
     
+    alias :lastname :last
+    
     ## @param [optional,Hash] h A hash of the person's attributes
     # @option h [String] :gender nil Gender, 'm' for male or 'f' for female
     # @option h [Integer] :age nil Age

data/lib/randomperson/version.rb

@@ -1,3 +1,3 @@
 module RandomPerson
-  VERSION = "0.0.19"
+  VERSION = "1.0.0"
 end

data/lib/randomperson.rb

@@ -1,4 +1,6 @@
 # encoding: UTF-8
+
+
 module RandomPerson
 
   #require all the scaffolding
@@ -14,10 +16,133 @@ module RandomPerson
   require_relative './randomperson/ext/Kernel.rb'
   require_relative './randomperson/ext/Set.rb'
   
-  require_relative './randomperson/choice.rb'
+  require_relative './randomperson/demographic.rb'
   require_relative './randomperson/generator.rb'
   require_relative './randomperson/name.rb'
   require_relative './randomperson/person.rb'
   #require_relative './randomperson/ratio.rb'
 
+
+  class Facade
+
+    def demographics
+      @demos ||= {}
+    end
+
+    #class instance variable to keep track of generators
+    def generators
+      @generators ||= {}
+    end
+
+
+    # little factory
+    def demographic( name=nil, opts={} )
+      if name.kind_of? Hash
+        opts = name
+        name = nil
+      end
+      name = demographics.length.to_s if name.nil?
+      demo = Demographic.new name, opts
+      demographics[name] = demo
+      generators.delete name # just in case it already exists
+      demo
+    end
+    
+    
+    # start afresh
+    def clear
+      @demos = nil
+      @generators = nil
+      @person = nil
+      @last_demo_name = nil
+    end
+    
+    alias :reset :clear
+    attr_accessor :last_demo_name
+
+
+    # The last person generated.
+    # If a demographic name is given that is different to the last then a new person is generated. If no name is given then the last is used.
+    def person( demo_name=nil )
+      person, last_demo_name = 
+        if demo_name.nil? 
+
+          if @person.nil?
+
+            # either generate a new one
+            gen_new( demo_name ) # gen a new person and get back demo name
+          else 
+
+            #  get last one
+            [@person, @last_demo_name]
+          end
+        else # demo name given
+
+          if demographics.has_key? demo_name
+
+            if demo_name == @last_demo_name
+
+              [@person, @last_demo_name]
+            else
+
+              gen_new( demo_name )
+            end
+          else 
+
+            if demographics.nil? || demographics.empty?
+
+              raise "No demographics have been selected yet! Try something like r.demographic.add_Spanish..." 
+            else # that demo name doesn't exist...
+
+              [nil, @last_demo_name] # so preserve the last good demo name
+            end
+          end
+        end
+        return nil if person.nil?
+        @person, @last_demo_name = [person, last_demo_name]
+
+      @person
+    end
+
+    
+    # generate a new person
+    # either with the last demographic loaded, or a specific one by passing the name.
+    def generate( demo_name=nil )
+      ds = gen_new( demo_name )
+      ds.nil? ? nil : ds.first
+    end
+
+
+    # If not given a demographic's name then the *last demographic defined* will be used.
+    def gen_new( demo_name=nil )
+      if demographics.nil? || demographics.empty?
+        raise "No demographics have been selected yet! Try something like r.demographic.add_Spanish..." 
+      end
+      demo_name, demo = if demo_name.nil?
+        demographics.to_a.last # this produces a 2 dimensional array
+      else
+        demographics.assoc(demo_name)
+      end
+      
+      if demo_name
+        @last_demo_name = demo_name
+        unless generators.has_key? demo.name
+          generators[demo.name] = Generator.make_generator( demo )
+        end
+  
+        @person = generators[@last_demo_name].call 
+          
+        [@person, @last_demo_name]
+      else
+        nil
+      end
+    end
+
+  end # class
+
+
+end
+
+def RandomPerson
+  RandomPerson::Facade.new
 end

data/spec/AmericanSuffix_spec.rb

@@ -0,0 +1,37 @@
+# encoding: UTF-8
+
+require_relative "./rspec_helper.rb"
+require_relative "./support/shared_examples/names.rb"
+require_relative "../lib/randomperson/Names/AmericanSuffix.rb"
+require_relative "../lib/randomperson/person.rb"
+
+module RandomPerson
+  module Names
+
+    describe AmericanSuffix do
+      let(:instance) { AmericanSuffix.new }
+      subject{ instance }
+      it_should_behave_like "a Name class"
+      describe :execute do
+        context "Who is young" do
+          let(:p) { instance.execute Person.new( age: 16) }
+          subject { p } 
+          it { should_not be_nil }
+          1000.times do |_|
+            it { should be_in instance.names[0..-2] }
+          end
+        end
+        context "Who is older" do
+          let(:p) { instance.execute Person.new( age: 18) }
+          subject { p } 
+          it { should_not be_nil }
+          1000.times do |_|
+            it { should be_in instance.names[1..-1] }
+          end
+        end
+      end # execute
+
+    end # AmericanSuffix
+
+  end # Names
+end # RandomPerson

data/spec/AnyLast_spec.rb

@@ -0,0 +1,25 @@
+# encoding: UTF-8
+
+require_relative "./rspec_helper.rb"
+require_relative "./support/shared_examples/names.rb"
+require_relative "../lib/randomperson/Names/AnyLast.rb"
+require_relative "../lib/randomperson/person.rb"
+
+module RandomPerson
+  module Names
+
+    describe AnyLast do
+      let(:instance) { AnyLast.new }
+      subject{ instance }
+      it_should_behave_like "a Name class"
+      describe :execute do
+        subject { instance.execute Person.new( gender: "m", age: rand(100)) }
+        it { should_not be_nil }
+        1000.times do |_|
+          it { should match /^ \b\p{Upper}\p{Alpha}+?\b (?:(?:\s|-)\b\p{Upper}\p{Alpha}+?\b)?$/x }
+        end
+      end # execute
+    end # AnyLast
+
+  end # Names
+end # RandomPerson

data/spec/Last_and_First_Names_spec.rb

@@ -0,0 +1,113 @@
+# encoding: UTF-8
+
+require_relative "./rspec_helper.rb"
+require_relative "./support/shared_examples/names.rb"
+require_relative "../lib/randomperson/person.rb"
+require_relative "../lib/randomperson/demographic.rb"
+
+module RandomPerson
+  module Names
+    
+    available_classes = Demographic.load_names
+    available_classes.each do |klass|
+      klass = Demographic.requiring klass
+      
+      k = eval "RandomPerson::Names::#{klass}"
+      
+        
+
+      word = /\b\p{Upper}\p{Alpha}+?\b (?:(?:\s|-)\b\p{Upper}\p{Alpha}+?\b)?/x
+      hypenated_rgx = /^#{word}$/x 
+      french_rgx = /^(?:(?: (?:\bLe\b\s) | (?:\bd[eu]\b)\s) | (?:#{word}-))? #{word}$/x
+      hypenated_many_rgx = /^#{word} (?:(?:\s|-)#{word})*$/x
+      unhypenated_rgx = /^#{word}\s#{word}?$/x 
+      poss_unhyph = /^#{word}(?:\s#{word})?$/
+      thai_style = /^\b\p{Graph}+?\b$/x
+      default_fix = {times: 50 } 
+      fixtures = {}
+      fixtures.default = default_fix
+      fixtures["SpanishLast"] = default_fix.merge({ rgx: /^ \b\p{Upper}(?:\p{Alpha}+-)?\p{Alpha}+?\b\s (?: (?:\bde\b\s) | (?: \b\p{Upper}(?:\p{Alpha}+-)?\p{Alpha}+?\b\s (?:\by\b\s)? ) )? \b\p{Upper}(?:\p{Alpha}+-)?\p{Alpha}+?\b$/x })
+      fixtures["AmericanLast"] = default_fix.merge({ rgx: hypenated_rgx } )
+      fixtures["AnyLast"] = default_fix.merge({ rgx: hypenated_rgx  } )
+      fixtures["BritishLast"] = default_fix.merge({ rgx: hypenated_rgx  } )
+      fixtures["EnglishLast"] = default_fix.merge({ rgx: hypenated_rgx  } )
+      fixtures["ScottishLast"] = default_fix.merge({ rgx: hypenated_rgx  } )
+      fixtures["WelshLast"] = default_fix.merge({ rgx: poss_unhyph  } )
+      fixtures["FrenchLast"] = default_fix.merge({ rgx: french_rgx} )
+      fixtures["FrenchFemaleFirst"] = default_fix.merge({ rgx: hypenated_rgx  } )
+      fixtures["FrenchMaleFirst"] = default_fix.merge({ rgx: hypenated_rgx  } )
+      fixtures["BasqueMaleFirst"] = default_fix.merge({ rgx: hypenated_rgx  } )
+      fixtures["BasqueLast"] = default_fix.merge({ rgx: unhypenated_rgx  } )
+      fixtures["ThaiRomanisedLast"] = default_fix.merge({ rgx: hypenated_rgx  } )
+      fixtures["ThaiFemaleFirst"] = default_fix.merge({ rgx: thai_style } )
+      fixtures["ThaiMaleFirst"] = default_fix.merge({ rgx: thai_style} )
+      fixtures["ThaiLast"] = default_fix.merge({ rgx: thai_style} )
+      fixtures["ThaiFirst"] = default_fix.merge({ rgx: thai_style} )
+      fixtures["ThaiRomanisedMaleFirst"] = default_fix.merge({ rgx: hypenated_many_rgx} )
+      fixtures["ThaiRomanisedFemaleFirst"] = default_fix.merge({ rgx: hypenated_many_rgx} )
+      fixtures["AncientGreekLast"] = default_fix.merge(
+        { rgx: /^\bof\b\s(?:\b\p{Alpha}+?\b(?:\s|-)){0,2}\b\p{Alpha}+?\b$/x } )
+      
+#PREFIXES
+      fix_fixtures = {}
+      fix_fixtures["FinnishPrefix"] = {
+        young_male: {gender: "m", age: rand(17), in: ["herra"]}, #rgx: /^\bherra\b$/x },
+        older_male: {gender: "m", in: ["herra", "Dr"]}, #rgx: /^\b(?:herra|Dr)\b$/x },
+        young_female: {gender: "f", age: rand(17), in: ["neiti"]}, #rgx: /^\bneiti\b$/x },
+        older_female: {gender: "f", age: rand(17), in: ["rouva", "neiti", "Dr"]} #rgx: /^\b(?:rouva)|(?:neiti)|(?:Dr)\b$/x },
+      }
+      fix_fixtures["SpanishPrefix"] = {
+        young_male: {gender: "m", age: rand(17), in: ["Sr."]}, #rgx: /^\bSr\b\.$/x },
+        older_male: {gender: "m", in: ["Sr.", "Dr."]}, #rgx: /^\b(?:[SD]r\b\.)$/x },
+        young_female: {gender: "f", age: rand(17), in: ["Srta."]}, #rgx: /^\bSrta\b.$/x },
+        older_female: {gender: "f", in: ["Dra.", "Srta.", "Sra."]}#rgx: /^[DS]rt?a\b\.$/x }
+      }
+      fix_fixtures["AmericanPrefix"] = {
+        young_female: {gender: "f", age: rand(17), rgx: /^\bMiss\b$/},
+        older_female: {gender: "f", in: ["Miss", "Mrs.", "Dr.", "Ms."]}, #rgx: /^\bM(?:(?:iss\b)|(?:(?:r?s)\b\.))$|(?:Dr\b\.$)/x },
+        young_male: {gender: "m", age: rand(17), in: ["Mr."]}, #rgx: /^\bMr\b\.$/},
+        older_male:  {gender: "m", in: ["Mr.", "Dr."]}, 
+      } #rgx: /^\b[MD]r\b\.$/}, }
+      fix_fixtures["AmericanSuffix"] = {
+        young_female: {},
+        older_female: {},
+        young_male: {},
+        older_male:  {} }
+      fix_fixtures["BritishPrefix"] = {
+        young_female: {gender: "f", age: rand(17), rgx: /^\bMiss\b$/},
+        older_female: {gender: "f", rgx: /^\b(?:M(?:is|r)?s)|(?:Dr)\b$/},
+        young_male: {gender: "m", age: rand(17), rgx: /^\bMr\b$/},
+        older_male:  {gender: "m", rgx: /^\b[MD]r\b$/}, }
+      fix_fixtures["EnglishPrefix"] = fix_fixtures["ScottishPrefix"] = fix_fixtures["WelshPrefix"] = fix_fixtures["BritishPrefix"]
+
+#SUFFIXES
+      fix_fixtures["BritishSuffix"] = {
+        young_female: {age: rand(17), gender: "f", in: [""] },
+        older_female: { gender: "f", in: %w( OBE MBE GBE KBE DBE CBE JP GM PhD BSc BA )}, 
+        young_male: {age: rand(17), gender: "m", in: [""] },
+        older_male: {gender: "m", in: %w( OBE MBE GBE KBE DBE CBE JP GM PhD BSc BA ) }, 
+      }
+      fix_fixtures["AmericanSuffix"] = { # strictly speaking, gender doesn't matter here, but I'll leave the test in.
+        young_female: {age: rand(17), gender: "f", in: [ 'Jr.', ''] + %w( I II III IV V) },
+        young_male: { age: rand(17), gender: "m", in: [ 'Jr.', ''] + %w( I II III IV V ) },
+        older_male: { gender: "m", in: [ ''] + %w( I II III IV V Sr. ) },
+        older_female: { gender: "f", in: [ ''] + %w( I II III IV V Sr. ) }, 
+      }
+
+
+      puts "Describe #{klass}" #because rspec doesn't output this before it blow up! Sheesh!!
+      describe klass do
+        let(:instance) { k.new }
+        subject{ instance }
+        it_should_behave_like "a Name class"
+        if ["Prefix", "Suffix"].any?{|x| klass.include? x }
+          
+          it_should_behave_like "it cares about gender and/or age", fix_fixtures[klass] 
+        else
+          it_should_behave_like "a name generator", fixtures[klass]
+        end
+      end # describe
+    end # loop
+
+  end # Names
+end # RandomPerson

data/spec/array_spec.rb

@@ -0,0 +1,49 @@
+# encoding: UTF-8
+
+require_relative "./rspec_helper.rb"
+require_relative "../lib/randomperson/ext/array.rb"
+
+describe Array do
+
+  describe :rand do
+    let(:m1) { 1_000_000 }
+    let(:r) { m1 * 10 }
+    let(:range) { 
+      u = rand(r) + m1
+      (u..u+10)
+    }
+    subject { range.to_a.rand }
+    it { range.cover?( subject ).should be_true } 
+  end
+
+  describe :index_in_range do
+    context "Given an number" do
+      let(:max) { 99 }
+      let(:array) {
+        array = []
+        i = 0
+        until i >= max 
+          last = array.empty? ? 0 : array.last.max + 1
+          i = (i == 0 ? rand(99) : rand(max - i)) + last 
+          array << (last..i)
+        end
+        array
+      }
+      context "That is not in the ranges in the array" do
+        let(:n) { max + 1}
+        subject{ array.index_in_range( n ) }
+        it { should be_nil }
+      end
+      context "That is in the ranges in the array" do
+        0.upto(99) do |n|
+          subject{ array.index_in_range( n ) }
+          it { subject.should_not be_nil }
+          it { should be_a_kind_of Integer}
+          it { should be_between( 0, array.length - 1 ) }
+        end
+      end
+    end
+  end # :index_in_range
+    
+
+end # Array

data/spec/demographic_spec.rb

@@ -0,0 +1,15 @@
+# encoding: UTF-8
+
+require 'rspec'
+require_relative "../lib/randomperson/demographic.rb"
+
+
+module RandomPerson
+  
+  describe Demographic do
+    
+    it "should not blow up on instatiation" do
+      Demographic.new.should_not == nil
+    end
+  end # Demographic
+end # RandomPerson

data/spec/generator_spec.rb

@@ -6,8 +6,5 @@ module RandomPerson
   
   describe Generator do
     
-    it "should not blow up on instatiation" do
-      Generator.new.should_not == nil
-    end
   end # Generator
-end # RandomPerson
+end # RandomPerson

data/spec/name_spec.rb

@@ -1,7 +1,8 @@
+# encoding: UTF-8
+
 require 'rspec'
 require_relative "../lib/randomperson/name.rb"
 
-
 module RandomPerson
   
   describe Name do
@@ -10,4 +11,4 @@ module RandomPerson
       Name.new.should_not == nil
     end
   end # Name
-end # RandomPerson
+end # RandomPerson