sanichi-chess_icu 0.1.0

data/.gitignore

@@ -0,0 +1,4 @@
+coverage
+doc
+pkg
+tmp

data/CHANGELOG

@@ -0,0 +1,2 @@
+* 0.1.0 2009-04-11
+* Initial version that parses foreign CSV files and has some basic name and date utilities.

data/LICENCE

@@ -0,0 +1,22 @@
+Copyright (c) 2009 Mark Orr
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,11 @@
+== ChessIcu
+
+For parsing files of chess tournament data into ruby classes.
+
+== Install
+
+  sudo gem install sanichi-chess_icu --source http://gems.github.com
+
+== Usage
+
+TODO

data/Rakefile

@@ -0,0 +1,41 @@
+require 'rubygems'
+require 'rake'
+require 'rake/rdoctask'
+require 'spec/rake/spectask'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "chess_icu"
+    gem.summary = "For parsing files of chess tournament data into ruby classes."
+    gem.homepage = "http://github.com/sanichi/chess_icu"
+    gem.authors = ["Mark Orr"]
+    gem.email = "mark.j.l.orr@googlemail.com"
+    gem.files = FileList['[A-Z]*', '{lib,spec}/**/*', '.gitignore']
+    gem.has_rdoc = true
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+task :default => :spec
+
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+  spec.spec_opts = ['--colour --format nested --loadby mtime --reverse']
+end
+
+Rake::RDocTask.new do |doc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'doc'
+  rdoc.title = "ChessIcu #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 0
+:minor: 1
+:patch: 0

data/lib/chess_icu.rb

@@ -0,0 +1,3 @@
+dir = File.dirname(__FILE__)
+%w{util name player result tournament}.each { |file| require "#{dir}/#{file}" }
+%w{fcsv}.each                               { |file| require "#{dir}/tournament_#{file}" }

data/lib/name.rb

@@ -0,0 +1,217 @@
+module ICU
+  class Name
+    attr_reader :first, :last
+    
+    def initialize(name1='', name2='')
+      @name1 = name1.to_s
+      @name2 = name2.to_s
+      canonicalize
+    end
+    
+    def name
+      name = @first
+      name << ' ' if @first.length > 0 && @last.length > 0
+      name << @last
+      name
+    end
+    
+    def rname
+      name = @last
+      name << ', ' if @first.length > 0 && @last.length > 0
+      name << @first
+      name
+    end
+    
+    def to_s
+      rname
+    end
+    
+    def match(name1='', name2='')
+      other = Name.new(name1, name2)
+      match_first(first, other.first) && match_last(last, other.last)
+    end
+    
+    private
+    
+    def canonicalize
+      first, last = partition
+      @first = finish_first(first)
+      @last  = finish_last(last)
+    end
+    
+    def partition
+      if @name2.length == 0
+        # Only one imput so we must split first and last.
+        parts = @name1.split(/,/)
+        if parts.size > 1
+          last  = clean(parts.shift || '')
+          first = clean(parts.join(' '))
+        else
+          parts = clean(@name1).split(/ /)
+          last  = parts.pop || ''
+          first = parts.join(' ')
+        end
+      else
+        # Two inputs, so we are given first and last.
+        first = clean(@name1)
+        last  = clean(@name2)
+      end
+      [first, last]
+    end
+        
+    def clean(name)
+      name.gsub!(/`/, "'")
+      name.gsub!(/[^-a-zA-Z.'\s]/, '')
+      name.gsub!(/\./, ' ')
+      name.gsub!(/\s*-\s*/, '-')
+      name.gsub!(/'+/, "'")
+      name.strip.downcase.split(/\s+/).map do |n|
+        n.sub!(/^-+/, '')
+        n.sub!(/-+$/, '')
+        n.split(/-/).map do |p|
+          p.capitalize!
+        end.join('-')
+      end.join(' ')
+    end
+    
+    def finish_first(names)
+      names.gsub(/([A-Z])\b/, '\1.')
+    end
+    
+    def finish_last(names)
+      names.gsub!(/\b([A-Z])'([a-z])/) { |m| $1 << "'" << $2.upcase}
+      names.gsub!(/\bMc([a-z])/) { |m| 'Mc' << $1.upcase}
+      names.gsub!(/\bMac([a-z])/) do |m|
+        letter = $1
+        'Mac'.concat(@name2.match("[mM][aA][cC]#{letter}") ? letter : letter.upcase)
+      end
+      names.gsub!(/\bO ([A-Z])/) { |m| "O'" << $1 }
+      names
+    end
+    
+    # Match a complete first name.
+    def match_first(first1, first2)
+      # Is this one a walk in the park?
+      return true if first1 == first2
+      
+      # No easy ride. Begin by splitting into individual first names.
+      first1 = split_first(first1)
+      first2 = split_first(first2)
+      
+      # Get the long list and the short list.
+      long, short = first1.size >= first2.size ? [first1, first2] : [first2, first1]
+      
+      # The short one must be a "subset" of the long one.
+      # An extra condition must also be satisfied.
+      extra = false
+      (0..long.size-1).each do |i|
+        lword = long.shift
+        score = match_first_name(lword, short.first)
+        if score >= 0
+          short.shift
+          extra = true if i == 0 || score == 0
+        end
+        break if short.empty? || long.empty?
+      end
+      
+      # There's a match if the following is true.
+      short.empty? && extra
+    end
+    
+    # Match a complete last name.
+    def match_last(last1, last2)
+      return true if last1 == last2
+      [last1, last2].each do |last|
+        last.downcase!             # MacDonaugh and Macdonaugh
+        last.gsub!(/\bmac/, 'mc')  # MacDonaugh and McDonaugh
+        last.tr!('-', ' ')         # Lowry-O'Reilly and Lowry O'Reilly
+      end
+      last1 == last2
+    end
+    
+    # Split a complete first name for matching.
+    def split_first(first)
+      first.tr!('-', ' ')              # J. K. and J.-K.
+      first = first.split(/ /)         # split on spaces
+      first = [''] if first.size == 0  # in case input was empty string
+      first
+    end
+    
+    # Match individual first names or initials.
+    # -1 = no match
+    #  0 = full match
+    #  1 = match involving 1 initial
+    #  2 = match involving 2 initials
+    def match_first_name(first1, first2)
+      initials = 0
+      initials+= 1 if first1.match(/^[A-Z]\.?$/)
+      initials+= 1 if first2.match(/^[A-Z]\.?$/)
+      return initials if first1 == first2
+      return 0 if initials == 0 && match_nick_name(first1, first2)
+      return -1 unless initials > 0
+      return initials if first1[0] == first2[0]
+      -1
+    end
+    
+    # Match two first names that might be equivalent nicknames.
+    def match_nick_name(nick1, nick2)
+      compile_nick_names unless @@nc
+      code1 = @@nc[nick1]
+      return false unless code1
+      code1 == @@nc[nick2]
+    end
+    
+    # Compile the nick names code hash when matching nick names is first attempted.
+    def compile_nick_names
+      @@nc = Hash.new
+      code = 1
+      @@nl.each do |nicks|
+        nicks.each do |n|
+          throw "duplicate name #{n}" if @@nc[n]
+          @@nc[n] = code
+        end
+        code+= 1
+      end
+    end
+    
+    # A array of data for matching nicknames and also a few common misspellings.
+    @@nc = nil
+    @@nl = <<EOF.split(/\n/).reject{|x| x.length == 0 }.map{|x| x.split(' ')}
+Abdul Abul
+Alexander Alex
+Anandagopal Ananda
+Anne Ann
+Anthony Tony
+Benjamin Ben
+Catherine Cathy Cath
+Daniel Danial Danny Dan
+David Dave
+Deborah Debbie
+Des Desmond
+Eamonn Eamon
+Edward Eddie Ed
+Eric Erick Erik
+Frederick Frederic Fred
+Gerald Gerry
+Gerhard Gerard Ger
+James Jim
+Joanna Joan Joanne
+John Johnny
+Jonathan Jon
+Kenneth Ken Kenny
+Michael Mike Mick Micky
+Nicholas Nick Nicolas
+Nicola Nickie Nicky
+Patrick Pat Paddy
+Peter Pete
+Philippe Philip Phillippe Phillip
+Rick Ricky
+Samual Sam Samuel
+Stefanie Stef
+Stephen Steven Steve
+Terence Terry
+Thomas Tom Tommy
+William Will Willy Willie Bill
+EOF
+  end
+end

data/lib/player.rb

@@ -0,0 +1,143 @@
+module ICU
+  class Player
+    attr_accessor :first_name, :last_name, :num, :id, :fed, :title, :rating, :rank, :dob
+    attr_reader :results
+    
+    def initialize(first_name, last_name, num, opt={})
+      self.first_name = first_name
+      self.last_name  = last_name
+      self.num        = num
+      [:id, :fed, :title, :rating, :rank, :dob].each do |atr|
+        self.send("#{atr}=", opt[atr]) unless opt[atr].nil?
+      end
+      @results = []
+    end
+    
+    def first_name=(first_name)
+      name = Name.new(first_name, 'Last')
+      raise "invalid first name" unless name.first.length > 0
+      @first_name = name.first
+    end
+    
+    def last_name=(last_name)
+      name = Name.new('First', last_name)
+      raise "invalid last name" unless name.last.length > 0 && name.first.length > 0
+      @last_name = name.last
+    end
+    
+    def name
+      "#{last_name}, #{first_name}"
+    end
+    
+    # Player number. Any integer.
+    def num=(num)
+      @num = case num
+        when Fixnum then num
+        else num.to_i
+      end
+      raise "invalid player number (#{num})" if @num == 0 && !num.to_s.match(/\d/)
+    end
+    
+    # National or FIDE ID. Is either unknown (nil) or a positive integer.
+    def id=(id)
+      @id = case id
+        when nil     then nil
+        when Fixnum  then id
+        when /^\s*$/ then nil
+        else id.to_i
+      end
+      raise "invalid ID (#{id})" unless @id.nil? || @id > 0
+    end
+    
+    # Federation. Is either unknown (nil) or contains at least three letters.
+    def fed=(fed)
+      @fed = fed.to_s.strip
+      @fed.upcase! if @fed.length == 3
+      @fed = nil if @fed == ''
+      raise "invalid federation (#{fed})" unless @fed.nil? || @fed.match(/[a-z]{3}/i)
+    end
+    
+    # Chess title. Is either unknown (nil) or one of a set of possibilities (after a little cleaning up).
+    def title=(title)
+      @title = title.to_s.strip.upcase
+      @title << 'M' if @title.match(/[A-LN-Z]$/)
+      @title = nil if @title == ''
+      raise "invalid chess title (#{title})" unless @title.nil? || @title.match(/^W?[GIFCN]M$/)
+    end
+    
+    # Elo rating. Is either unknown (nil) or a positive integer.
+    def rating=(rating)
+      @rating = case rating
+        when nil     then nil
+        when Fixnum  then rating
+        when /^\s*$/ then nil
+        else rating.to_i
+      end
+      raise "invalid rating (#{rating})" unless @rating.nil? || @rating > 0
+    end
+    
+    # Rank in the tournament. Is either unknown (nil) or a positive integer.
+    def rank=(rank)
+      @rank = case rank
+        when nil     then nil
+        when Fixnum  then rank
+        when /^\s*$/ then nil
+        else rank.to_i
+      end
+      raise "invalid rank (#{rank})" unless @rank.nil? || @rank > 0
+    end
+    
+    # Date of birth. Is either unknown (nil) or a yyyy-mm-dd format date.
+    def dob=(dob)
+      dob = dob.to_s.strip
+      @dob = dob == '' ? nil : Util.parsedate(dob)
+      raise "invalid DOB (#{dob})" if @dob.nil? && dob.length > 0
+    end
+    
+    # Add a result.
+    def add_result(result)
+      raise "invalid result" unless result.class == ICU::Result
+      raise "player number (#{@num}) is not matched to result player number (#{result.player})" unless @num == result.player
+      raise "round number (#{result.round}) of new result should be unique" unless @results.map { |r| r.round }.grep(result.round).size == 0
+      @results << result
+    end
+    
+    # Lookup a result by round number.
+    def find_result(round)
+      @results.find { |r| r.round == round }
+    end
+    
+    # Return the player's total points.
+    def points
+      @results.inject(0.0) { |t, r| t += r.points }
+    end
+    
+    # Loose equality test.
+    def ==(other)
+      return true if equal?(other)
+      return false unless other.is_a? Player
+      return false unless @first_name == other.first_name
+      return false unless @last_name  == other.last_name
+      return false if @fed && other.fed && @fed != other.fed
+      true
+    end
+    
+    # Strict equality test.
+    def eql?(other)
+      return true if equal?(other)
+      return false unless self == other
+      [:id, :rating, :title].each do |m|
+        return false if self.send(m) && other.send(m) && self.send(m) != other.send(m)
+      end
+      true
+    end
+    
+    # Merge in some of the details of another player.
+    def subsume(other)
+      raise "cannot merge two players that are not strictly equal" unless eql?(other)
+      [:id, :rating, :title, :fed].each do |m|
+        self.send("#{m}=", other.send(m)) if other.send(m)
+      end
+    end
+  end
+end