randomperson 1.3.0 → 1.4.0

data/lib/randomperson/name.rb

@@ -1,11 +1,11 @@
 # encoding: UTF-8
 
-require_relative "./ext/array.rb"
 require_relative "./outputter.rb"
 
 
 module RandomPerson
 
+  # The base class for a name-data class.
   class Name
     include Outputter
     

data/lib/randomperson/outputter.rb

@@ -2,22 +2,47 @@
 
 # uses the @on_execute block of the including class
 module Outputter
+
+  # ClassMethods
+  # @api private
   module ClassMethods
     
   end # ClassMethods
-  
+
+
+  # Instance methods
+  # @api private
   module InstanceMethods
+
+    # Block to execute when instance is ready.
+    # @example
+    #   # In the AmericanSuffix constructor
+    #   # Some help to make sure suffixes are age appropriate.
+    #   on_execute do |person|
+    #     r = rand(99)      
+    #     if person.age > 17
+    #       r += 1 #Jr can't happen and Snr can
+    #     end
+    #     #
+    #     @possibles.each_pair{|k,v| break v if k === r }
+    #   end
+    # @api private
     def on_execute( &block )
       @on_execute = block
     end
 
+
+    # Command pattern
+    # @api private
     def execute( person=nil )
       @on_execute.call( person )
     end
     
     private 
-    
-#TODO rename this as other classes are using it too
+
+    # Handles the outputting of prefixes like Mr, Mrs etc.
+    #TODO rename this as other classes are using it too
+    # @api private
     def for_prefixes( for_females, for_males,  male_upper_bound=50, child_age_upper_bound=16, female_lower_bound=50)
       
       ->(person){
@@ -32,7 +57,10 @@ module Outputter
         name
       }
     end # prefixes
-    
+
+
+    # Handles the outputting for the rest of the name.
+    # @api private
     def for_standard
       ->(person=nil){
         f = if @formats.length > 1
@@ -45,7 +73,10 @@ module Outputter
       }
     end
   end
-  
+
+
+  # Classic hooking in.
+  # @api private
   def self.included(receiver)
     receiver.extend         ClassMethods
     receiver.send :include, InstanceMethods

data/lib/randomperson/ratio.rb

@@ -1,5 +1,6 @@
 module RandomPerson #namespace
 
+  # Handles ratios for demographics e.g. 1 male for 1 female.
   module Ratio
   
     #create a ratio that is made up of ranges
@@ -12,7 +13,8 @@ module RandomPerson #namespace
       new_ratio.shift #get rid of 0..0
       return new_ratio
     end 
-    
+
+
     #find the order of magnitude of a number for use with this module
     def ordmag( n )
       m = 10
@@ -22,8 +24,11 @@ module RandomPerson #namespace
       end
       m
     end
-    
+
+
     #use this method if you don't have a ratio at all for an array and, hey presto! It'll make one for you
+    # @param [Integer] len Length
+    # @param [Integer] mag Magnitude
     def presto_rangio( len, mag )
       return [ ] unless len >= 1
       l, m = len, mag

data/lib/randomperson/version.rb

@@ -1,3 +1,6 @@
 module RandomPerson
-  VERSION = "1.3.0"
+
+  # Version number of this library.
+  # @see http://semver.org/ for how this pattern works.
+  VERSION = "1.4.0"
 end

data/randomperson.gemspec

@@ -4,6 +4,7 @@ require File.expand_path( '../lib/randomperson/version', __FILE__ )
 Gem::Specification.new do |s|
   s.authors         = ["Iain Barnett"]
   s.email           = ["iainspeed@gmail.com"]
+  s.license         = "MIT"
   s.description = <<-EOF
     RandomPerson is a port to Ruby of Perl's Data::RandomPerson. Use it to generate random persons given various parameters, such as country, age and gender ratio.
   EOF
@@ -16,11 +17,5 @@ Gem::Specification.new do |s|
   s.name            = "randomperson"
   s.require_paths   = ['lib']
   s.version         = RandomPerson::VERSION
-  s.add_development_dependency( "wirble" )
-  s.add_development_dependency( "rspec" )
-  s.add_development_dependency( "rake" )
-  s.add_development_dependency( "simplecov" )
-  s.add_development_dependency( "yard" )
-  s.add_development_dependency( "redcarpet" ) # for yard
-  s.required_ruby_version    = ">= 1.9.1"
+  s.required_ruby_version    = ">= 2.0.0"
 end

data/spec/last_and_first_names_spec.rb

@@ -4,26 +4,37 @@ require "spec_helper"
 require_relative "./support/shared_examples/names.rb"
 require_relative "../lib/randomperson/person.rb"
 require_relative "../lib/randomperson/demographic.rb"
+require_relative "../lib/randomperson.rb"
 require_relative "./support/helpers.rb"
 
 module RandomPerson
   module Names
 
-    Demographic.new.require_and_add(Demographic.load_names).each do |klass|
-      klass = klass.split("::").last
+  describe "RandomPerson::Names" do
 
-      puts "Describe #{klass}" #because rspec doesn't output this before it blow up! Sheesh!!
-      describe klass do
-        let(:instance) { RandomPerson::Constant.new("RandomPerson::Names::#{klass}").to_constant.new }
+    before :all do
+      Demographic.new.require_and_add(Demographic.load_names)
+    end
+
+
+    RandomPerson().loaded_classes.each do |klass|
+      klass_basename = klass.name.split("::").last
+
+      puts "Describe #{klass.name}" #because rspec doesn't output this before it blow up! Sheesh!!
+      describe klass_basename do
+        let(:instance) { 
+          klass.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", RandomPerson::Spec::Helpers.fix_fixtures[klass] 
+        if ["Prefix", "Suffix"].any?{|x| klass_basename.include? x }
+          it_should_behave_like "it cares about gender and/or age", RandomPerson::Spec::Helpers.fix_fixtures[klass_basename] 
         else
-          it_should_behave_like "a name generator", RandomPerson::Spec::Helpers.fixtures[klass]
+          it_should_behave_like "a name generator", RandomPerson::Spec::Helpers.fixtures[klass_basename]
         end
       end # describe
     end # loop
+  end
 
   end # Names
 end # RandomPerson

data/spec/randomperson_spec.rb

@@ -3,52 +3,8 @@
 require "spec_helper"
 require_relative "../lib/randomperson.rb"
 
-shared_examples "a Person" do
-  it { subject.first.should_not be_nil }
-  it { subject.first.should be_a_kind_of String }
-  it { subject.last.should_not be_nil }
-  it { subject.last.should be_a_kind_of String }
-  it { subject.prefix.should_not be_nil }
-  it { subject.prefix.should be_a_kind_of String }
-end
-
-shared_examples "there is more than one demographic" do
-  context "Given a new demographic" do
-    before(:all) { r.demographic("America").add_American }
-    context "but not changing to it" do
-      let(:last_run) { r.person }
-      subject { last_run } 
-      it { should equal first_run }
-      context "changing to the new demographic" do
-        let(:new_demo_person) { r.person "America" }
-        subject { new_demo_person } 
-        it { should_not equal last_run }
-      end
-    end
-  end
-end
-
-shared_examples "getting the last person" do
-  context "on first run" do
-    subject{ first_run }
-    it_behaves_like "a Person"
-    context "on next run" do
-      context "Given no demographic" do
-        subject { r.person }
-        it { should equal first_run }
-      end
-      context "Given the same demographic" do
-        subject{ r.person "Spain" }
-        it { should equal first_run }
-        it_behaves_like "there is more than one demographic"
-      end
-    end
-  end
-end
-
 shared_examples "clear or reset" do
-  let(:r) { RandomPerson() }
-  before(:all) {
+  Given!(:before) {
     r.demographic("Spain").add_Spanish
     r.demographic("Finland").add_Finnish
     r.generate "Spain"
@@ -57,45 +13,44 @@ shared_examples "clear or reset" do
     r.generate
     r.generate "Spain"
   }
-  subject { r.clear }
-  it { should be_nil }
-  specify { r.should_not be_nil }
-  specify { r.should be_a_kind_of RandomPerson::Facade }
-  specify { r.generators.should be_empty }
-  specify { r.demographics.should be_empty }
+  Then { r.clear.nil? }
+  And { r.should_not be_nil }
+  And { r.should be_a_kind_of RandomPerson::Facade }
+  And { r.generators.should be_empty }
+  And { r.demographics.should be_empty }
 end
 
 
 describe RandomPerson do
-  
+  Given(:r) { RandomPerson() }
+
   describe :person do
-    let(:r) { RandomPerson() }
     context "Given a demographic" do
       context "With a name" do
-        context "and one demographic specified" do
-          before(:all) {
+        demo_name = "Spain"
+        context "and one demographic specified, that of #{demo_name}," do
+          Given!(:spanish_was_added) {
             r.demographic("Spain").add_Spanish
           }
-          let(:first_run) { r.person "Spain" }
-          subject{ first_run }
-          it_behaves_like "a Person"
+          Given(:first_run) { r.person "Spain" }
+          Then { first_run.first.should_not be_nil }
+          And { first_run.first.should be_a_kind_of String }
+          And { first_run.last.should_not be_nil }
+          And { first_run.last.should be_a_kind_of String }
+          And { first_run.prefix.should_not be_nil }
+          And { first_run.prefix.should be_a_kind_of String }
           context "on next run" do
             context "Given no demographic" do
-              subject { r.person }
-              it { should equal first_run }
+              Then { r.person == first_run }
               context "and then given the same demographic explicitly" do
-                subject{ r.person "Spain" }
-                it { should equal first_run }
+                Then { r.person("Spain") == first_run }
                 context "and then given a demo name that doesn't exist" do
-                  subject{ r.person "Spurious" }
-                  it { should be_nil }
+                  Then { r.person("Spurious").nil? }
                   context "and then given no demo name" do
-                    subject{ r.person }
-                    it { should equal first_run }
+                    Then { r.person == first_run }
                   end
                   context "and then given the last good demographic explicitly" do
-                    subject{ r.person "Spain" }
-                    it { should equal first_run }
+                    Then { r.person("Spain") == first_run }
                   end
                 end
               end
@@ -104,42 +59,69 @@ describe RandomPerson do
         end
 
         context "and no demographic specified" do
-          before(:all) {
+          Given!(:spanish_was_added) {
             r.demographic("Spain").add_Spanish
           }
-          let(:first_run) { r.person }
-          it_behaves_like "getting the last person"
+          context "on first run" do
+            Given!(:first_run) { r.person }
+            Then { first_run.first.should_not be_nil }
+            And { first_run.first.should be_a_kind_of String }
+            And { first_run.last.should_not be_nil }
+            And { first_run.last.should be_a_kind_of String }
+            And { first_run.prefix.should_not be_nil }
+            And { first_run.prefix.should be_a_kind_of String }
+            context "on next run" do
+              context "Given no demographic" do
+                When(:person) { r.person }
+                Then { person == first_run }
+              end
+              context "Given the same demographic" do
+                When(:spanish){ r.person "Spain" }
+                Then { spanish == first_run }
+                context "there is more than one demographic" do
+                  context "Given a new demographic" do
+                    Given(:american_added) { r.demographic("America").add_American }
+                    context "but not changing to it" do
+                      When(:r_person) { r.person }
+                      Then { r_person == first_run }
+                      context "changing to the new demographic" do
+                        Given(:new_demo_person) { r.person "America" }
+                        When(:new_person) { new_demo_person }
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
         end
           
       end
       
       context "Without a name" do
         context "and with a demographic specified" do
-          before(:all) {
+          Given(:spanish_without_a_name) {
             r.clear
             r.demographic.add_Spanish
           }
-          subject { r.person "Spain" }
-          it { should be_nil }
+          When(:person_is_spanish) { r.person "Spain" }
+          Then { person_is_spanish.nil? }
         end
 
         context "and no demographic specified" do
-          before(:all) {
-            r.demographic.add_Spanish
-          }
-          let(:first_run) { r.person }
-          subject { r.person }
-          it { should equal first_run }
+          Given!(:spanish_added) { r.demographic.add_Spanish }
+          When(:first_run) { r.person }
+          Then { r.person == first_run }
           context "on repeated runs" do
-            before(:all) {
+            Given!(:clearing) {
               r.clear
               r.demographic.add_Spanish
               r.generate
               r.generate
             }
-            let(:last) { r.person }
-            subject { r.person }
-            it { should equal last }
+            Given(:last_generated) { r.person }
+            When(:person_generated) { r.person }
+            Then { person_generated == last_generated }
           end
             
         end
@@ -147,29 +129,21 @@ describe RandomPerson do
     end
 
     context "With no demographic" do
-      context "Already loaded" do
-        before { r.demographics.clear }
-        subject { r.person }
-        it { should be_a_kind_of RandomPerson::Person }
-        context "and given a demo name (that does not exist)" do
-          subject { r.person "Not loaded" }
-          it { should be_nil }
-        end
-      end
+      Given!(:cleared) { r.demographics.clear }
+      Then { r.person.kind_of? RandomPerson::Person }
+      Then { r.person("Not loaded").nil? }
       context "Because they've been cleared" do
-        before { r.demographics.clear }
-        subject { r.person }
-        it { should be_a_kind_of RandomPerson::Person }
+        Then { r.person.kind_of? RandomPerson::Person }
         context "and given a demo name (that does not exist)" do
-          subject { r.person "Been cleared" }
-          it { should be_nil }
+          Then { r.person("Been cleared").nil? }
           context "and given a block with a raise" do
-            subject { 
-              r.person "Does not exist" do
-                fail "This demo name does not exist!"
-              end
+            Then {
+              expect {
+                r.person "Does not exist" do
+                  fail "This demo name does not exist!"
+                end
+              }
             }
-            specify { expect { subject }.to raise_error }
           end
         end
       end
@@ -178,26 +152,23 @@ describe RandomPerson do
   
   
   describe :generators do
-    let(:r) { RandomPerson() }
-    before(:all) {
+    Given(:spanish_and_finish_added) {
       r.demographic("Spain").add_Spanish
       r.demographic("Finland").add_Finnish
     }
     context "Before first run" do
-      subject { r.generators }
-      it { should be_empty }
+      Then { r.generators.empty? }
     end
     context "First run" do
-      before { 
+      Given(:some_people_are_generated) {
         r.generate "Spain"
         r.generate
         r.generate "Finland"
         r.generate
         r.generate "Spain"
       }
-      subject { r.generators }
-      it { should_not be_empty }
-      specify { subject.keys.should include("Spain", "Finland") } 
+      Then { r.generators.empty? }
+      And { r.generators.keys.all?{|x| (x == "Spain") || (x == "Finland")}} 
     end
   end # generators
   
@@ -210,117 +181,119 @@ describe RandomPerson do
   end
   
   describe :generate do
-    let(:r) { RandomPerson() }
     context "Before a demographic has been loaded" do
-      subject { r.generate }
-      it { should_not be_nil }
-      it { should be_a_kind_of RandomPerson::Person }
+      Then { !r.generate.nil? }
+      And { r.generate.kind_of? RandomPerson::Person }
     end
     context "When there is a demographic loaded" do
-      before(:all) {
+      Given!(:demographic) {
         r.demographic("Spain").add_Spanish
       }
-      let(:people) { 
+      Given(:people) {
         people = []
         1000.times{ people << r.generate }
         people
       }
       context "Given a demographic name" do
         context "That has been added to demographics" do
-          subject { r.generate "Spain" }
-          it { should_not be_nil }
-          it { should be_a_kind_of RandomPerson::Person }
-          it_behaves_like "a Person"
-          it { should_not satisfy {|person| people.include? person } }
+          When(:spanish) { r.generate "Spain" }
+          Then { !spanish.nil? }
+          And { spanish.kind_of? RandomPerson::Person }
+          And { spanish.first.should_not be_nil }
+          And { spanish.first.should be_a_kind_of String }
+          And { spanish.last.should_not be_nil }
+          And { spanish.last.should be_a_kind_of String }
+          And { spanish.prefix.should_not be_nil }
+          And { spanish.prefix.should be_a_kind_of String }
+          Then { !people.include?(spanish) }
         end
         context "That has not been added to demographics" do
-          subject { r.generate "Spurious" }
-          it { should be_nil }
+          When(:spurious) { r.generate "Spurious" }
+          Then { spurious.nil? }
         end
       end
       context "Given a no demographic name" do
-        subject { r.generate }
-        it { should_not be_nil }
-        it { should be_a_kind_of RandomPerson::Person }
-        it_behaves_like "a Person"
-        it { should_not satisfy {|person| people.include? person } }
+        Then { !r.generate.nil? }
+        And { r.generate.kind_of? RandomPerson::Person }
+        And { r.generate.first.should_not be_nil }
+        And { r.generate.first.should be_a_kind_of String }
+        And { r.generate.last.should_not be_nil }
+        And { r.generate.last.should be_a_kind_of String }
+        And { r.generate.prefix.should_not be_nil }
+        And { r.generate.prefix.should be_a_kind_of String }
+        And { !people.include? r.generate }
       end
     end
     context "When there is no demographic loaded" do
-      context "Given a demographic name" do
-        subject { r.generate "Spain" }
-      end
+      When(:spain) { r.generate "Spain" }
+      Then { spain.nil? }
+      When(:no_name) { r.generate }
+      Then { !no_name.nil? }
     end
   end
     
   
   describe :demographics do
-    let(:r) { RandomPerson() }
     context "With no demographics loaded" do
-      subject { r.demographics }
-      it { should be_empty }
-      it { should be_a_kind_of Hash }
+      Then { r.demographics.empty? }
+      And { r.demographics.kind_of? Hash }
     end
     context "Given a demographic" do
       context "With a name" do
-        before(:all) {
+        Given!(:spanish_added) {
           r.demographic("Spain").add_Spanish
         }
-        subject { r.demographics }
-        it { should_not be_empty }
-        it { should be_a_kind_of Hash }
-        specify { subject.first.should be_a_kind_of Array }
-        specify { subject.first.first.should be_a_kind_of String }
-        specify { subject.first.last.should be_a_kind_of RandomPerson::Demographic }
+        Then { !r.demographics.empty? }
+        And { r.demographics.kind_of? Hash }
+        And { r.demographics.first.kind_of? Array }
+        And { r.demographics.first.first.kind_of? String }
+        And { r.demographics.first.last.kind_of? RandomPerson::Demographic }
       end
       context "Without a name" do
-        before(:all) {
+        Given!(:demo_spanish) {
           r.demographic.add_Spanish
         }
-        subject { r.demographics }
-        it { should_not be_empty }
-        it { should be_a_kind_of Hash }
-        specify { subject.first.should be_a_kind_of Array }
-        specify { subject.first.first.should be_a_kind_of String }
-        specify { subject.first.last.should be_a_kind_of RandomPerson::Demographic }
+        Then { !r.demographics.empty? }
+        And { r.demographics.kind_of? Hash }
+        And { r.demographics.first.kind_of? Array }
+        And { r.demographics.first.first.kind_of? String }
+        And { r.demographics.first.last.kind_of? RandomPerson::Demographic }
       end
       
       context "With options" do
         context "With a named demographic" do
-          let(:lower){ rand(99) }
-          let(:upper){ rand(100 - lower) + lower }
-          let(:females) { rand(10) } 
-          let(:males) { rand(10) }
-          before(:all) {
+          Given(:lower){ rand(99) }
+          Given(:upper){ rand(100 - lower) + lower }
+          Given(:females) { rand(10) }
+          Given(:males) { rand(10) }
+          Given!(:demo) {
             r.demographic("Random!", gender_ratio: [females,males] , age_lower: lower, age_upper: upper ).add_Spanish
           }
-          subject { r.demographics }
-          it { should_not be_empty }
-          it { should be_a_kind_of Hash }
-          specify { subject.first.should be_a_kind_of Array }
-          specify { subject.first.first.should be_a_kind_of String }
-          specify { subject.first.last.should be_a_kind_of RandomPerson::Demographic }
-          specify { subject.first.last.age_lower.should == lower }
-          specify { subject.first.last.age_upper.should == upper }
-          specify { subject.first.last.gender_ratio.should == [females,males] }
+          Then { !r.demographics.empty? }
+          And { r.demographics.kind_of? Hash }
+          And { r.demographics.first.should be_a_kind_of Array }
+          And { r.demographics.first.first.should be_a_kind_of String }
+          And { r.demographics.first.last.should be_a_kind_of RandomPerson::Demographic }
+          And { r.demographics.first.last.age_lower.should == lower }
+          And { r.demographics.first.last.age_upper.should == upper }
+          And { r.demographics.first.last.gender_ratio.should == [females,males] }
         end
         context "Without a named demographic" do
-          let(:lower){ rand(99) }
-          let(:upper){ rand(100 - lower) + lower }
-          let(:females) { rand(10) } 
-          let(:males) { rand(10) }
-          before(:all) {
+          Given(:lower){ rand(99) }
+          Given(:upper){ rand(100 - lower) + lower }
+          Given(:females) { rand(10) }
+          Given(:males) { rand(10) }
+          Given!(:spanish_was_added) {
             r.demographic(gender_ratio: [females,males] , age_lower: lower, age_upper: upper ).add_Spanish
           }
-          subject { r.demographics }
-          it { should_not be_empty }
-          it { should be_a_kind_of Hash }
-          specify { subject.first.should be_a_kind_of Array }
-          specify { subject.first.first.should be_a_kind_of String }
-          specify { subject.first.last.should be_a_kind_of RandomPerson::Demographic }
-          specify { subject.first.last.age_lower.should == lower }
-          specify { subject.first.last.age_upper.should == upper }
-          specify { subject.first.last.gender_ratio.should == [females,males] }
+          Then { r.demographics.kind_of? Hash }
+          And { !r.demographics.empty? }
+          And { r.demographics.first.should be_a_kind_of Array }
+          And { r.demographics.first.first.should be_a_kind_of String }
+          And { r.demographics.first.last.should be_a_kind_of RandomPerson::Demographic }
+          And { r.demographics.first.last.age_lower.should == lower }
+          And { r.demographics.first.last.age_upper.should == upper }
+          And { r.demographics.first.last.gender_ratio.should == [females,males] }
         end
       end
     end