sanichi-chess_icu 0.1.0

data/lib/result.rb

@@ -0,0 +1,103 @@
+module ICU
+  class Result
+    attr_reader :round, :player, :score, :colour, :opponent, :rateable
+    
+    def initialize(round, player, score, opt={})
+      self.round  = round
+      self.player = player
+      self.score  = score
+      [:colour, :opponent].each { |a| self.send("#{a}=", opt[a]) unless opt[a].nil? }
+      self.rateable = opt[:rateable]  # always attempt to set this, and do it last, to get the right default
+    end
+    
+    # Round number. Must be a positive integer.
+    def round=(round)
+      @round = round.to_i
+      raise "invalid round number (#{round})" unless @round > 0
+    end
+    
+    # Player number. Can be any integer.
+    def player=(player)
+      @player = case player
+        when Fixnum then player
+        else player.to_i
+      end
+      raise "invalid player number (#{player})" if @player == 0 && !player.to_s.match(/\d/)
+    end
+    
+    # Score for the game, even if a default. One of 'W', 'L' or 'D' (after some cleaning up).
+    def score=(score)
+      @score = case score.to_s.strip
+        when /^(1\.0|1|\+|W|w)$/ then 'W'
+        when /^(0\.5|½|\=|D|d)$/ then 'D'
+        when /^(0\.0|0|\-|L|l)$/ then 'L'
+        else raise "invalid score (#{score})"
+      end
+    end
+    
+    # The score as a number.
+    def points
+      case @score
+        when 'W' then 1.0
+        when 'L' then 0.0
+        else 0.5
+      end
+    end
+    
+    # Colour. Either 'W' or 'B' after some cleaning up.
+    def colour=(colour)
+      @colour = case colour.to_s
+        when ''   then nil
+        when /W/i then 'W'
+        when /B/i then 'B'
+        else raise "invalid colour (#{colour})"
+      end
+    end
+    
+    # Opponent player number. Either absent (nil) or any integer except the player number.
+    def opponent=(opponent)
+      @opponent = case opponent
+        when nil     then nil
+        when Fixnum  then opponent
+        when /^\s*$/ then nil
+        else opponent.to_i
+      end
+      raise "invalid opponent number (#{opponent})" if @opponent == 0 && !opponent.to_s.match(/\d/)
+      raise "opponent number and player number (#{@opponent}) must be different" if @opponent == player
+      self.rateable = true if @opponent
+    end
+    
+    # Rateable flag. If false, game is not rateable. Can only be true if there is an opponent.
+    def rateable=(rateable)
+      if opponent.nil?
+        @rateable = false
+        return
+      end
+      @rateable = case rateable
+        when nil   then true   # default (when absent) is true
+        when false then false  # this is the only way to turn it off
+        else true
+      end
+    end
+    
+    # Reverse a result so it is seen from the opponent's perspective.
+    def reverse(rateable=nil)
+      return unless @opponent
+      r = Result.new(@round, @opponent, @score == 'W' ? 'L' : (@score == 'L' ? 'W' : 'D'))
+      r.opponent = @player
+      r.colour = 'W' if @colour == 'B'
+      r.colour = 'B' if @colour == 'W'
+      r.rateable = rateable || @rateable
+      r
+    end
+    
+    # Loose equality.
+    def ==(other)
+      return unless other.is_a? Result
+      [:round, :player, :opponent, :colour, :score].each do |m|
+        return false unless self.send(m) == other.send(m)
+      end
+      true
+    end
+  end
+end

data/lib/tournament.rb

@@ -0,0 +1,81 @@
+module ICU
+  class Tournament
+    attr_reader :name, :start, :rounds, :site
+    
+    # Constructor.
+    def initialize(name, start, opt={})
+      self.name  = name
+      self.start = start
+      [:rounds, :site].each { |a| self.send("#{a}=", opt[a]) unless opt[a].nil? }
+      @player = {}
+    end
+    
+    # Tournament name.
+    def name=(name)
+      raise "invalid tournament name (#{name})" unless name.to_s.match(/[a-z]/i)
+      @name = name.to_s.strip
+    end
+    
+    # Start data in yyyy-mm-dd format.
+    def start=(start)
+      start = start.to_s.strip
+      @start = Util.parsedate(start)
+      raise "invalid start date (#{start})" unless @start
+    end
+    
+    # Number of rounds. Is either unknown (nil) or a positive integer.
+    def rounds=(rounds)
+      @rounds = case rounds
+        when nil     then nil
+        when Fixnum  then rounds
+        when /^\s*$/ then nil
+        else rounds.to_i
+      end
+      raise "invalid number of rounds (#{rounds})" unless @rounds.nil? || @rounds > 0
+    end
+    
+    # Web site. Either unknown or a reasonably valid looking URL.
+    def site=(site)
+      @site = site.to_s.strip
+      @site = nil if @site == ''
+      @site = "http://#{@site}" if @site && !@site.match(/^https?:\/\//)
+      raise "invalid site (#{site})" unless @site.nil? || @site.match(/^https?:\/\/[-\w]+(\.[-\w]+)+(\/[^\s]*)?$/i)
+    end
+    
+    # Add players.
+    def add_player(player)
+      raise "invalid player" unless player.class == ICU::Player
+      raise "player number (#{player.num}) should be unique" if @player[player.num]
+      @player[player.num] = player
+    end
+    
+    # Get a player by their number.
+    def player(num)
+      @player[num]
+    end
+    
+    # Return an array of all the players.
+    def players
+      @player.values
+    end
+    
+    # Lookup a player in the tournament.
+    def find_player(player)
+      players.find { |p| p == player }
+    end
+    
+    # Add results.
+    def add_result(result, reverse_rateable=true)
+      raise "invalid result" unless result.class == ICU::Result
+      raise "result round number (#{result.round}) inconsistent with number of tournament rounds" if @rounds && result.round > @rounds
+      raise "player number (#{result.player}) does not exist" unless @player[result.player]
+      @player[result.player].add_result(result)
+      if result.opponent
+        raise "opponent number (#{result.opponent}) does not exist" unless @player[result.opponent]
+        reverse = result.reverse
+        reverse.rateable = false unless reverse_rateable
+        @player[result.opponent].add_result(reverse)
+      end
+    end
+  end
+end

data/lib/tournament_fcsv.rb

@@ -0,0 +1,155 @@
+require 'fastercsv'
+
+module ICU
+  class Tournament
+    class ForeignCSV
+      attr_reader :tournament
+    
+      # Constructor.
+      def initialize(csv)
+        @state, @line, @round, @sum = 0, 0, nil, nil
+        parse(csv)
+      end
+      
+      private
+      
+      def parse(csv)
+        @tournament = Tournament.new('Dummy', '2000-01-01')
+        FasterCSV.parse(csv, :row_sep => :auto) do |r|
+          @line += 1                            # increment line number
+          next if r.size == 0                   # skip empty lines
+          r = r.map{|c| c.nil? ? '' : c.strip}  # trim all spaces, turn nils to blanks
+          next if r[0] == ''                    # skip blanks in column 1
+          @r = r                                # remember this record for later
+          
+          begin
+            case @state
+              when 0 then event
+              when 1 then start
+              when 2 then rounds
+              when 3 then website
+              when 4 then player
+              when 5 then result
+              when 6 then total
+              else raise "internal error - state #{@state} does not exist"
+            end
+          rescue => err
+            raise err.class, "line #{@line}: #{err.message}", err.backtrace unless err.message.match(/^line [1-9]/)
+            raise
+          end
+        end
+        
+        unless @state == 4
+          exp = case @state
+                when 0 then "the event name"
+                when 1 then "the start date"
+                when 2 then "the number of rounds"
+                when 3 then "the website address"
+                when 5 then "a result for round #{@round+1}"
+                when 6 then "a total score"
+                end
+          raise "line #{@line}: premature termination - expected #{exp}"
+        end
+        raise "line #{@line}: no players found in file" if @tournament.players.size == 0
+      end
+      
+      def event
+        abort "the 'Event' keyword", 0 unless @r[0].match(/^(Event|Tournament)$/i)
+        abort "the event name",      1 unless @r.size > 1 && @r[1] != ''
+        @tournament.name = @r[1]
+        @state = 1
+      end
+      
+      def start
+        abort "the 'Start' keyword", 0 unless @r[0].match(/^(Start(\s+Date)?|Date)$/i)
+        abort "the start date",      1 unless @r.size > 1 && @r[1] != ''
+        @tournament.start = @r[1]
+        @state = 2
+      end
+      
+      def rounds
+        abort "the 'Rounds' keyword", 0 unless @r[0].match(/(Number of )?Rounds$/)
+        abort "the number of rounds", 1 unless @r.size > 1 && @r[1].match(/^[1-9]\d*/)
+        @tournament.rounds = @r[1]
+        @state = 3
+      end
+      
+      def website
+        abort "the 'Website' keyword", 0 unless @r[0].match(/^(Web(\s?site)?|Site)$/i)
+        abort "the event website",     1 unless @r.size > 1 && @r[1] != ''
+        @tournament.site = @r[1]
+        @state = 4
+      end
+      
+      def player
+        abort "the 'Player' keyword",  0 unless @r[0].match(/^Player$/i)
+        abort "a player's ICU number", 1 unless @r.size > 1 && @r[1].match(/^[1-9]/i)
+        abort "a player's last name",  2 unless @r.size > 2 && @r[2].match(/[a-z]/i)
+        abort "a player's first name", 3 unless @r.size > 3 && @r[3].match(/[a-z]/i)
+        @player = Player.new(@r[3], @r[2], @tournament.players.size + 1, :id => @r[1])
+        old_player = @tournament.find_player(@player)
+        if old_player
+          raise "two players with the same name (#{@player.name}) have conflicting details" unless old_player.eql?(@player)
+          raise "same player (#{@player.name}) has more than one set of results" if old_player.id
+          old_player.subsume(@player)
+          @player = old_player
+        else
+          @tournament.add_player(@player)
+        end
+        @round = 0
+        @state = 5
+      end
+      
+      def result
+        @round+= 1
+        abort "round number #{round}",              0 unless @r[0].to_i == @round
+        abort "a colour (W/B) or dash (for a bye)", 2 unless @r.size > 2 && @r[2].match(/^(W|B|-)/i)
+        result = Result.new(@round, @player.num, @r[1])
+        if @r[2] == '-'
+          @tournament.add_result(result)
+        else
+          result.colour = @r[2]
+          opponent = Player.new(@r[4], @r[3], @tournament.players.size + 1, :rating => @r[5], :title => @r[6], :fed => @r[7])
+          raise "opponent must have a rating and federation" unless opponent.rating && opponent.fed
+          old_player = @tournament.find_player(opponent)
+          if old_player
+            raise "two players with the same name (#{opponent.name}) have conflicting details" unless old_player.eql?(opponent)
+            result.opponent = old_player.num
+            if old_player.id
+              old_player.subsume(opponent)
+              old_result = @player.find_result(@round)
+              raise "missing result for player (#{@player.name}) in round #{@round}" unless old_result
+              raise "mismatched results for player (#{old_player.name}) in round #{@round}" unless result == old_result
+              old_result.rateable = true
+            else
+              old_result = old_player.find_result(@round)
+              raise "a player (#{old_player.name}) has more than one game in the same round (#{@round})" if old_result
+              @tournament.add_result(result, false)
+            end
+          else
+            @tournament.add_player(opponent)
+            result.opponent = opponent.num
+            @tournament.add_result(result, false)
+          end
+        end
+        @state = 6 if @round == @tournament.rounds
+      end
+      
+      def total
+        points = @player.points
+        abort "the 'Total' keyword", 0 unless @r[0].match(/^Total$/i)
+        abort "the player's (#{@player.object_id}, #{@player.results.size}) total points to be #{points}", 1 unless @r[1].to_f == points
+        @state = 4
+      end
+      
+      def abort(expected, cell)
+        got = @r[cell]
+        error = "line #{@line}"
+        error << ", cell #{cell+1}"
+        error << ": expected #{expected}"
+        error << " but got #{got == '' ? 'a blank cell' : "'#{got}'"}"
+        raise error
+      end
+    end
+  end
+end

data/lib/util.rb

@@ -0,0 +1,15 @@
+module ICU
+  class Util
+    # Parse dates into yyyy-mm-dd format, preferring European format. Return nil on error.
+    def self.parsedate(date)
+      date = date.to_s
+      return nil unless date.match(/[1-9]/)
+      date.sub!(/^([1-9]|0[1-9]|[12][0-9]|3[01])([^\d])([1-9]|0[1-9]|1[0-2])([^\d])/, '\3\2\1\4')
+      begin
+        Date.parse(date, true).to_s
+      rescue
+        return nil
+      end
+    end
+  end
+end

data/spec/name_spec.rb

@@ -0,0 +1,172 @@
+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 "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
+      it "should be possible in simple cases" do
+        Name.new('ORR, mark j l').name.should == 'Mark J. L. Orr'
+        Name.new('MARK J L ORR').name.should == 'Mark J. L. Orr'
+        Name.new("O'Reilly, j-k").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