icu_tournament 0.8.9

data/lib/icu_tournament/util.rb

@@ -0,0 +1,156 @@
+module ICU
+  class Util
+
+=begin rdoc
+
+== Loading the best CSV parser
+
+For Ruby 1.8.7 the CSV parser used here was FasterCSV (in preference to CSV from the standard library).
+From Ruby 1.9.1, the standard CSV is replaced by an updated version of FasterCSV while the old
+FasterCSV remains incompatible with the new Ruby. ICU::Util::CSV is therefore set to whichever
+class is the right one for the version of Ruby being used.
+
+== Parsing dates
+
+Parse dates into yyyy-mm-dd format, preferring European over US convention. Returns nil on error.
+
+  Util.parsedate('1955-11-09')       # => '1955-11-09'
+  Util.parsedate('02/03/2009')       # => '2009-03-02'
+  Util.parsedate('02/23/2009')       # => '2009-02-23'
+  Util.parsedate('16th June 1986')   # => '1986-06-16'
+
+Note that the parse method of the Date class behaves differently in Ruby 1.8.7 and 1.9.1.
+In 1.8.7 it assumes American dates and will raise ArgumentError on "30/03/2003".
+In 1.9.1 it assumes European dates and will raise ArgumentError on "03/30/2003".
+
+=end
+
+    if RUBY_VERSION > '1.9'
+      require 'csv'
+      CSV = ::CSV
+    else
+      require 'fastercsv'
+      CSV = ::FasterCSV
+    end
+
+    def self.parsedate(date)
+      date = date.to_s.strip
+      return nil unless date.match(/[1-9]/)
+      date = [$3].concat($2.to_i > 12 ? [$1, $2] : [$2, $1]).join('-') if date.match(/^(\d{1,2}).(\d{1,2}).(\d{4})$/)
+      begin
+        Date.parse(date, true).to_s
+      rescue
+        nil
+      end
+    end
+  end
+  
+  module Accessor
+    def attr_accessor(name, &block)
+      attr_reader name
+      if block
+        define_method("#{name}=") do |val|
+          val = block.call(val)
+          instance_variable_set("@#{name}", val)
+        end
+      end
+    end
+    
+    def attr_integer(*names)
+      names.each do |name|
+        attr_accessor(name) do |val|
+          tmp = val.to_i
+          raise "invalid integer (#{val}) for #{name}" unless val.is_a?(Fixnum) || (val.is_a?(String) && val.include?(tmp.to_s))
+          tmp
+        end
+      end
+    end
+    
+    def attr_integer_or_nil(*names)
+      names.each do |name|
+        attr_accessor(name) do |val|
+          tmp = case val
+            when nil      then nil
+            when Fixnum   then val
+            when /^\s*$/  then nil
+            else val.to_i
+          end
+          raise "invalid integer (#{val}) for #{name}" if tmp == 0 && val.is_a?(String) && !val.include?('0')
+          tmp
+        end
+      end
+    end
+    
+    def attr_positive(*names)
+      names.each do |name|
+        attr_accessor(name) do |val|
+          tmp = val.to_i
+          raise "invalid positive integer (#{val}) for #{name}" unless tmp > 0
+          tmp
+        end
+      end
+    end
+    
+    def attr_positive_or_nil(*names)
+      names.each do |name|
+        attr_accessor(name) do |val|
+          tmp = case val
+            when nil      then nil
+            when Fixnum   then val
+            when /^\s*$/  then nil
+            else val.to_i
+          end
+          raise "invalid positive integer or nil (#{val}) for #{name}" unless tmp.nil? || tmp > 0
+          tmp
+        end
+      end
+    end
+  
+    def attr_date(*names)
+      names.each do |name|
+        attr_accessor(name) do |val|
+          tmp = val.to_s.strip
+          tmp = ICU::Util::parsedate(tmp)
+          raise "invalid date (#{val}) for #{name}" unless tmp
+          tmp
+        end
+      end
+    end
+  
+    def attr_date_or_nil(*names)
+      names.each do |name|
+        attr_accessor(name) do |val|
+          tmp = val.to_s.strip
+          if tmp == ''
+            tmp = nil
+          else
+            tmp = ICU::Util::parsedate(tmp)
+            raise "invalid date or nil (#{val}) for #{name}" unless tmp
+          end
+          tmp
+        end
+      end
+    end
+    
+    def attr_string(regex, *names)
+      names.each do |name|
+        attr_accessor(name) do |val|
+          tmp = val.to_s.strip
+          raise "invalid #{name} (#{val})" unless tmp.match(regex)
+          tmp
+        end
+      end
+    end
+    
+    def attr_string_or_nil(regex, *names)
+      names.each do |name|
+        attr_accessor(name) do |val|
+          tmp = val.to_s.strip
+          tmp = nil if tmp == ''
+          raise "invalid #{name} (#{val})" unless tmp.nil? || tmp.match(regex)
+          tmp
+        end
+      end
+    end
+  end
+end

data/spec/federation_spec.rb

@@ -0,0 +1,176 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+module ICU
+  describe Federation do
+    context "#find using codes" do
+      it "should find a federation given a valid code" do
+        fed = Federation.find('IRL')
+        fed.code.should == 'IRL'
+        fed.name.should == 'Ireland'
+      end
+      
+      it "should find a federation from code case insensitively" do
+        fed = Federation.find('rUs')
+        fed.code.should == 'RUS'
+        fed.name.should == 'Russia'
+      end
+      
+      it "should find a federation despite irrelevant whitespace" do
+        fed = Federation.find('  mex    ')
+        fed.code.should == 'MEX'
+        fed.name.should == 'Mexico'
+      end
+      
+      it "should return nil for an invalid code" do
+        Federation.find('XYZ').should be_nil
+      end
+    end
+    
+    context "#find using names" do
+      it "should find a federation given a valid name" do
+        fed = Federation.find('England')
+        fed.code.should == 'ENG'
+        fed.name.should == 'England'
+      end
+      
+      it "should find a federation from name case insensitively" do
+        fed = Federation.find('franCE')
+        fed.code.should == 'FRA'
+        fed.name.should == 'France'
+      end
+      
+      it "should not be fooled by irrelevant whitespace" do
+        fed = Federation.find(' united  states  of  america ')
+        fed.code.should == 'USA'
+        fed.name.should == 'United States of America'
+      end
+      
+      it "should return nil for an invalid name" do
+        Federation.find('Mordor').should be_nil
+      end
+    end
+    
+    context "#find using parts of names" do
+      it "should find a federation given a substring which is unique and at least 4 characters" do
+        fed = Federation.find('bosni')
+        fed.code.should == 'BIH'
+        fed.name.should == 'Bosnia and Herzegovina'
+      end
+      
+      it "should not be fooled by irrelevant whitespace" do
+        fed = Federation.find('  arab    EMIRATES   ')
+        fed.code.should == 'UAE'
+        fed.name.should == 'United Arab Emirates'
+      end
+      
+      it "should not find a federation if the substring matches more than one" do
+        Federation.find('land').should be_nil
+      end
+      
+      it "should return nil for any string smaller in length than 3" do
+        Federation.find('ze').should be_nil
+      end
+    end
+    
+    context "#find federations with alternative names" do
+      it "should find Macedonia multiple ways" do
+        Federation.find('MKD').name.should == 'Macedonia'
+        Federation.find('FYROM').name.should == 'Macedonia'
+        Federation.find('macedoni').name.should == 'Macedonia'
+        Federation.find('Macedonia').name.should == 'Macedonia'
+        Federation.find('former YUG Rep').name.should == 'Macedonia'
+        Federation.find('Republic of Macedonia').name.should == 'Macedonia'
+        Federation.find('former yugoslav republic').name.should == 'Macedonia'
+      end
+    end
+      
+    context "#find with alternative inputs" do
+      it "should behave robustly with completely invalid inputs" do
+        Federation.find().should be_nil
+        Federation.find(nil).should be_nil
+        Federation.find('').should be_nil
+        Federation.find(1).should be_nil
+      end
+    end
+    
+    context "#new is private" do
+      it "#new cannot be called directly" do
+        lambda { Federation.new('IRL', 'Ireland') }.should raise_error(/private method/)
+      end
+    end
+    
+    context "documentation examples" do
+      it "should all be correct for valid input" do
+        Federation.find('IRL').name.should == 'Ireland'
+        Federation.find('IRL').code.should == 'IRL'
+        Federation.find('rUs').code.should == 'RUS'
+        Federation.find('ongoli').name.should == 'Mongolia'
+        Federation.find('  united   states   ').code.should == 'USA'
+      end
+      
+      it "should return nil for invalid input" do
+        Federation.find('ZYX').should be_nil
+        Federation.find('land').should be_nil
+      end
+    end
+    
+    context "#menu" do
+      before(:all) do
+        @total = 173
+      end
+      
+      it "should return array of name-code pairs in order of name by default" do
+        menu = Federation.menu
+        menu.should have(@total).items
+        names = menu.map{|m| m.first}.join(',')
+        codes = menu.map{|m| m.last}.join(',')
+        names.index('Afghanistan').should == 0
+        names.index('Iraq,Ireland,Israel').should_not be_nil
+        codes.index('AFG').should == 0
+        codes.index('IRQ,IRL,ISR').should_not be_nil
+      end
+      
+      it "should be configuarble to order the list by codes" do
+        menu = Federation.menu(:order => "code")
+        menu.should have(@total).items
+        names = menu.map{|m| m.first}.join(',')
+        codes = menu.map{|m| m.last}.join(',')
+        names.index('Afghanistan').should == 0
+        names.index('Ireland,Iraq,Iceland').should_not be_nil
+        codes.index('AFG').should == 0
+        codes.index('IRL,IRQ,ISL').should_not be_nil
+      end
+      
+      it "should be configuarble to have a selected country at the top" do
+        menu = Federation.menu(:top => 'IRL')
+        menu.should have(@total).items
+        names = menu.map{|m| m.first}.join(',')
+        codes = menu.map{|m| m.last}.join(',')
+        names.index('Ireland,Afghanistan').should == 0
+        names.index('Iraq,Israel').should_not be_nil
+        codes.index('IRL,AFG').should == 0
+        codes.index('IRQ,ISR').should_not be_nil
+      end
+      
+      it "should be configuarble to have 'None' entry at the top" do
+        menu = Federation.menu(:none => 'None')
+        menu.should have(@total + 1).items
+        names = menu.map{|m| m.first}.join(',')
+        codes = menu.map{|m| m.last}.join(',')
+        names.index('None,Afghanistan').should == 0
+        codes.index(',AFG').should == 0
+      end
+      
+      it "should be able to handle multiple configuarations" do
+        menu = Federation.menu(:top => 'IRL', :order => 'code', :none => 'None')
+        menu.should have(@total + 1).items
+        names = menu.map{|m| m.first}.join(',')
+        codes = menu.map{|m| m.last}.join(',')
+        names.index('None,Ireland,Afghanistan').should == 0
+        names.index('Iraq,Iceland').should_not be_nil
+        codes.index(',IRL,AFG').should == 0
+        codes.index('IRQ,ISL').should_not be_nil
+      end
+    end
+  end
+end

data/spec/name_spec.rb

@@ -0,0 +1,208 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+module ICU
+  describe Name do
+    context "public methods" do
+      before(:each) do
+        @simple = Name.new('mark j l', 'orr')
+      end
+      
+      it "#first returns the first name(s)" do
+        @simple.first.should == 'Mark J. L.'
+      end
+      
+      it "#last returns the last name(s)" do
+        @simple.last.should == 'Orr'
+      end
+      
+      it "#name returns the full name with first name(s) first" do
+        @simple.name.should == 'Mark J. L. Orr'
+      end
+      
+      it "#rname returns the full name with last name(s) first" do
+        @simple.rname.should == 'Orr, Mark J. L.'
+      end
+      
+      it "#to_s is the same as rname" do
+        @simple.to_s.should == 'Orr, Mark J. L.'
+      end
+      
+      it "#match returns true if and only if two names match" do
+        @simple.match('mark j l orr').should be_true
+        @simple.match('malcolm g l orr').should be_false
+      end
+    end
+    
+    context "rdoc expample" do
+      before(:each) do
+        @robert = Name.new(' robert  j ', ' FISCHER ')
+        @bobby = Name.new(' bobby fischer ')
+      end
+      
+      it "should get Robert" do
+        @robert.name.should == 'Robert J. Fischer'
+      end
+      
+      it "should get Bobby" do
+        @bobby.last.should == 'Fischer'
+        @bobby.first.should == 'Bobby'
+      end
+      
+      it "should match Robert and Bobby" do
+        @robert.match(@bobby).should be_true
+        @robert.match('R. J.', 'Fischer').should be_true
+        @bobby.match('R. J.', 'Fischer').should be_false
+      end
+      
+      it "should canconicalise last names" do
+        Name.new('John', 'O Reilly').last.should == "O'Reilly"
+        Name.new('dave', 'mcmanus').last.should == "McManus"
+        Name.new('pete', 'MACMANUS').last.should == "MacManus"
+      end
+    end
+    
+    context "names that are already canonical" do
+      it "should not be altered" do
+        Name.new('Mark J. L.', 'Orr').name.should == 'Mark J. L. Orr'
+        Name.new('Anna-Marie J.-K.', 'Liviu-Dieter').name.should == 'Anna-Marie J.-K. Liviu-Dieter'
+      end
+    end
+    
+    context "last names beginning with a single letter followed by a quote" do
+      it "should be handled correctly" do
+        Name.new('una', "O'boyle").name.should == "Una O'Boyle"
+        Name.new('jonathan', 'd`arcy').name.should == "Jonathan D'Arcy"
+        Name.new('erwin e', "L'AMI").name.should == "Erwin E. L'Ami"
+        Name.new('cormac', "o brien").name.should == "Cormac O'Brien"
+      end
+    end
+    
+    context "last beginning with Mc" do
+      it "should be handled correctly" do
+        Name.new('shane', "mccabe").name.should == "Shane McCabe"
+        Name.new('shawn', "macDonagh").name.should == "Shawn MacDonagh"
+        Name.new('shawn', "macdonagh").name.should == "Shawn Macdonagh"
+        Name.new('bartlomiej', "macieja").name.should == "Bartlomiej Macieja"
+      end
+    end
+    
+    context "doubled barrelled names or initials" do
+      it "should be handled correctly" do
+        Name.new('anna-marie', 'den-otter').name.should == 'Anna-Marie Den-Otter'
+        Name.new('j-k', 'rowling').name.should == 'J.-K. Rowling'
+        Name.new("mark j. - l", 'ORR').name.should == 'Mark J.-L. Orr'
+        Name.new('JOHANNA', "lowry-o'REILLY").name.should == "Johanna Lowry-O'Reilly"
+        Name.new('hannah', "lowry - o reilly").name.should == "Hannah Lowry-O'Reilly"
+      end
+    end
+    
+    context "extraneous white space" do
+      it "should be handled correctly" do
+        Name.new(' mark j   l  ', "  \t\r\n   orr   \n").name.should == 'Mark J. L. Orr'
+      end
+    end
+    
+    context "extraneous full stops" do
+      it "should be handled correctly" do
+        Name.new('. mark j..l', 'orr.').name.should == 'Mark J. L. Orr'
+      end
+    end
+    
+    context "construction from a single string" do
+      before(:each) do
+        @mark1 = Name.new('ORR, mark j l')
+        @mark2 = Name.new('MARK J L ORR')
+        @oreil = Name.new("O'Reilly, j-k")
+      end
+      
+      it "should be possible in simple cases" do
+        @mark1.first.should == 'Mark J. L.'
+        @mark1.last.should == 'Orr'
+        @mark2.first.should == 'Mark J. L.'
+        @mark2.last.should == 'Orr'
+        @oreil.name.should == "J.-K. O'Reilly"
+      end
+    end
+    
+    context "construction from an instance" do
+      it "should be possible" do
+        Name.new(Name.new('ORR, mark j l')).name.should == 'Mark J. L. Orr'
+      end
+    end
+        
+    context "constuction corner cases" do
+      it "should be handled correctly" do
+        Name.new('Orr').name.should == 'Orr'
+        Name.new('Orr').rname.should == 'Orr'
+        Name.new('').name.should == ''
+        Name.new('').rname.should == ''
+        Name.new.name.should == ''
+        Name.new.rname.should == ''
+      end
+    end
+    
+    context "inputs to matching" do
+      before(:all) do
+        @mark = Name.new('Mark', 'Orr')
+        @kram = Name.new('Mark', 'Orr')
+      end
+      
+      it "should be flexible" do
+        @mark.match('Mark', 'Orr').should be_true
+        @mark.match('Mark Orr').should be_true
+        @mark.match('Orr, Mark').should be_true
+        @mark.match(@kram).should be_true
+      end
+    end
+
+    context "first name matches" do
+      it "should match when first names are the same" do
+        Name.new('Mark', 'Orr').match('Mark', 'Orr').should be_true
+      end
+      
+      it "should be flexible with regards to hyphens in double barrelled names" do
+        Name.new('J.-K.', 'Rowling').match('J. K.', 'Rowling').should be_true
+        Name.new('Joanne-K.', 'Rowling').match('Joanne K.', 'Rowling').should be_true
+      end
+      
+      it "should match initials" do
+        Name.new('M. J. L.', 'Orr').match('Mark John Legard', 'Orr').should be_true
+        Name.new('M.', 'Orr').match('Mark', 'Orr').should be_true
+        Name.new('M. J. L.', 'Orr').match('Mark', 'Orr').should be_true
+        Name.new('M.', 'Orr').match('M. J.', 'Orr').should be_true
+        Name.new('M. J. L.', 'Orr').match('M. G.', 'Orr').should be_false
+      end
+      
+      it "should not match on full names not in first position or without an exact match" do
+        Name.new('J. M.', 'Orr').match('John', 'Orr').should be_true
+        Name.new('M. J.', 'Orr').match('John', 'Orr').should be_false
+        Name.new('M. John', 'Orr').match('John', 'Orr').should be_true
+      end
+      
+      it "should handle common nicknames" do
+        Name.new('William', 'Orr').match('Bill', 'Orr').should be_true
+        Name.new('David', 'Orr').match('Dave', 'Orr').should be_true
+        Name.new('Mick', 'Orr').match('Mike', 'Orr').should be_true
+      end
+      
+      it "should not mix up nick names" do
+        Name.new('David', 'Orr').match('Bill', 'Orr').should be_false
+      end
+    end
+    
+    context "last name matches" do
+      it "should be flexible with regards to hyphens in double barrelled names" do
+        Name.new('Johanna', "Lowry-O'Reilly").match('Johanna', "Lowry O'Reilly").should be_true
+      end
+      
+      it "should be case insensitive in matches involving Macsomething and MacSomething" do
+        Name.new('Alan', 'MacDonagh').match('Alan', 'Macdonagh').should be_true
+      end
+      
+      it "should cater for the common mispelling of names beginning with Mc or Mac" do
+        Name.new('Alan', 'McDonagh').match('Alan', 'MacDonagh').should be_true
+        Name.new('Darko', 'Polimac').match('Darko', 'Polimc').should be_false
+      end
+    end
+  end
+end