icu_tournament 1.3.1 → 1.3.2

data/lib/icu_tournament/player.rb

@@ -84,7 +84,7 @@ module ICU
   class Player
     extend ICU::Accessor
     attr_integer :num
-    attr_positive_or_nil :id, :fide, :rating, :fide_rating, :rank
+    attr_positive_or_nil :id, :fide_id, :rating, :fide_rating, :rank
     attr_date_or_nil :dob
 
     attr_reader :results, :first_name, :last_name, :fed, :title, :gender
@@ -94,7 +94,7 @@ module ICU
       self.first_name = first_name
       self.last_name  = last_name
       self.num        = num
-      [:id, :fide, :fed, :title, :rating, :fide_rating, :rank, :dob, :gender].each do |atr|
+      [:id, :fide_id, :fed, :title, :rating, :fide_rating, :rank, :dob, :gender].each do |atr|
         self.send("#{atr}=", opt[atr]) unless opt[atr].nil?
       end
       @results = []
@@ -192,7 +192,7 @@ module ICU
     def eql?(other)
       return true if equal?(other)
       return false unless self == other
-      [:id, :fide, :rating, :fide_rating, :title, :gender].each do |m|
+      [:id, :fide_id, :rating, :fide_rating, :title, :gender].each do |m|
         return false if self.send(m) && other.send(m) && self.send(m) != other.send(m)
       end
       true
@@ -201,7 +201,7 @@ module ICU
     # Merge in some of the details of another player.
     def merge(other)
       raise "cannot merge two players that are not equal" unless self == other
-      [:id, :fide, :rating, :fide_rating, :title, :fed, :gender].each do |m|
+      [:id, :fide_id, :rating, :fide_rating, :title, :fed, :gender].each do |m|
         self.send("#{m}=", other.send(m)) unless self.send(m)
       end
     end

data/lib/icu_tournament/tournament_krause.rb

@@ -51,7 +51,7 @@ module ICU
     # By default, ID numbers and ratings in the input are interpreted as local IDs and ratings. If, instead, they should be interpreted as
     # FIDE IDs and ratings, add the following option:
     #
-    #   tournament = parser.parse_file('tournament.tab', :fide => true)
+    #   tournament = parser.parse_file('tournament.tab', :fide_id => true)
     #   daffy = tournament.player(2)
     #   daffy.id                          # => nil
     #   daffy.fide                        # => 7654321
@@ -87,8 +87,8 @@ module ICU
     # By default, local (ICU) IDs and ratings are used for the serialization, but both methods accept an option that
     # causes FIDE IDs and ratings to be used instead:
     #
-    #   krause = parser.serialize(tournament, :fide => true)
-    #   krause = tournament.serialize('Krause', :fide => true)
+    #   krause = parser.serialize(tournament, :fide_id => true)
+    #   krause = tournament.serialize('Krause', :fide_id => true)
     #
     # The following lists Krause data identification numbers, their description and, where available, their corresponding
     # attributes in an ICU::Tournament instance.
@@ -270,7 +270,7 @@ module ICU
           :dob    => @data[65, 10],
           :rank   => @data[81, 4],
         }
-        opt[arg[:fide] ? :fide : :id] = @data[53, 11]
+        opt[arg[:fide] ? :fide_id : :id] = @data[53, 11]
         opt[arg[:fide] ? :fide_rating : :rating] = @data[44, 4]
         player = Player.new(nam.first, nam.last, num, opt)
         @tournament.add_player(player)
@@ -342,7 +342,7 @@ module ICU
       krause << sprintf(' %-33s', "#{@last_name},#{@first_name}")
       krause << sprintf(' %4s', arg[:fide] ? @fide_rating : @rating)
       krause << sprintf(' %3s', @fed)
-      krause << sprintf(' %11s', arg[:fide] ? @fide : @id)
+      krause << sprintf(' %11s', arg[:fide] ? @fide_id : @id)
       krause << sprintf(' %10s', @dob)
       krause << sprintf(' %4.1f', points)
       krause << sprintf(' %4s', @rank)

data/lib/icu_tournament/tournament_sp.rb

@@ -68,7 +68,7 @@ module ICU
         :first_name  => "FIRSTNAME",
         :gender      => "SEX",
         :id          => "LOC_ID",
-        :fide        => "INTL_ID",
+        :fide_id     => "INTL_ID",
         :last_name   => "SURNAME",
         :num         => "ID",
         :rank        => "ORDER",
@@ -249,7 +249,7 @@ module ICU
           when :fed         then val = val && val.match(/^[A-Z]{3}$/i) ? val.upcase : nil
           when :gender      then val = val.to_i > 0 ? %w(M F)[val.to_i-1] : nil
           when :id          then val = val.to_i > 0 ? val : nil
-          when :fide        then val = val.to_i > 0 ? val : nil
+          when :fide_id     then val = val.to_i > 0 ? val : nil
           when :rating      then val = val.to_i > 0 ? val : nil
           when :fide_rating then val = val.to_i > 0 ? val : nil
           when :title       then val = val.to_i > 0 ? %w(GM WGM IM WIM FM WFM)[val.to_i-1] : nil

data/lib/icu_tournament/tournament_spx.rb

@@ -78,7 +78,7 @@ module ICU
     #
     # Or supply whatever columns you want, for example:
     #
-    #   tournament.serialize('SPExport', :columns => [:fide, :fide_rating])
+    #   tournament.serialize('SPExport', :columns => [:fide_id, :fide_rating])
     #
     # Note that the column order in the serialised string is the same as it is in the SwissPerfect application.
     # The order of column names in the _columns_ hash has no effect.
@@ -189,7 +189,7 @@ module ICU
         columns = Array.new
         columns.push(:num)
         columns.push(:name)
-        [:fed, :fide, :id, :fide_rating, :rating, :title, :points].each { |x| columns.push(x) if optional.include?(x) }
+        [:fed, :fide_id, :id, :fide_rating, :rating, :title, :points].each { |x| columns.push(x) if optional.include?(x) }
         
         # SwissPerfect headers for each column (other than the rounds, which are treated separately).
         header = Hash.new
@@ -198,7 +198,7 @@ module ICU
           when :num         then "No"
           when :name        then "Name"
           when :fed         then "Feder"
-          when :fide        then "Intl Id"
+          when :fide_id     then "Intl Id"
           when :id          then "Loc Id"
           when :fide_rating then "Rtg"
           when :rating      then "Loc"
@@ -259,13 +259,13 @@ module ICU
           key = case item
           when 'No'      then :num
           when 'Name'    then :name
-          when 'Total'   then :total
-          when 'Loc Id'  then :id
-          when 'Intl Id' then :fide
-          when 'Title'   then :title
           when 'Feder'   then :fed
-          when 'Loc'     then :rating
+          when 'Intl Id' then :fide_id
+          when 'Loc Id'  then :id
           when 'Rtg'     then :fide_rating
+          when 'Loc'     then :rating
+          when 'Title'   then :title
+          when 'Total'   then :points
           when /^[1-9]\d*$/
             round   = item.to_i
             @rounds = round if round > @rounds
@@ -287,7 +287,7 @@ module ICU
         num  = items[@header[:num]]
         name = Name.new(items[@header[:name]])
         opt  = Hash.new
-        [:fed, :title, :id, :fide, :rating, :fide_rating].each do |key|
+        [:fed, :title, :id, :fide_id, :rating, :fide_rating].each do |key|
           if @header[key]
             val = items[@header[key]]
             opt[key] = val unless val.nil? || val == ''
@@ -299,7 +299,7 @@ module ICU
         @tournament.add_player(player)
 
         # Save the results for later processing.
-        points = items[@header[:total]] if @header[:total]
+        points = items[@header[:points]] if @header[:points]
         points = nil if points == ''
         points = points.to_f if points
         total = 0.0;

data/lib/icu_tournament/version.rb

@@ -2,6 +2,6 @@
 
 module ICU
   class Tournament
-    VERSION = "1.3.1"
+    VERSION = "1.3.2"
   end
 end

data/spec/player_spec.rb

@@ -77,13 +77,13 @@ module ICU
 
     context "FIDE ID" do
       it "defaults to nil" do
-        Player.new('Stephen', 'Brady', 1).fide.should be_nil
+        Player.new('Stephen', 'Brady', 1).fide_id.should be_nil
       end
 
       it "should be a positive integer" do
-        Player.new('Stephen', 'Brady', 1, :fide => 2500124).fide.should == 2500124
-        Player.new('Gary', 'Kasparov', 2, :fide => '4100018').fide.should == 4100018
-        lambda { Player.new('Mark', 'Orr', 3, :fide => ' 0 ') }.should raise_error(/invalid positive integer/)
+        Player.new('Stephen', 'Brady', 1, :fide_id => 2500124).fide_id.should == 2500124
+        Player.new('Gary', 'Kasparov', 2, :fide_id => '4100018').fide_id.should == 4100018
+        lambda { Player.new('Mark', 'Orr', 3, :fide_id => ' 0 ') }.should raise_error(/invalid positive integer/)
       end
     end
 
@@ -238,8 +238,8 @@ module ICU
     context "merge" do
       before(:each) do
         @p1 = Player.new('Mark', 'Orr', 1, :id => 1350)
-        @p2 = Player.new('Mark', 'Orr', 2, :rating => 2100, :title => 'IM', :fed => 'IRL', :fide => 2500035)
-        @p3 = Player.new('Gearoidin', 'Ui Laighleis', 3, :rating => 1600, :title => 'WIM', :fed => 'IRL', :fide =>  2501171)
+        @p2 = Player.new('Mark', 'Orr', 2, :rating => 2100, :title => 'IM', :fed => 'IRL', :fide_id => 2500035)
+        @p3 = Player.new('Gearoidin', 'Ui Laighleis', 3, :rating => 1600, :title => 'WIM', :fed => 'IRL', :fide_id =>  2501171)
       end
 
       it "takes on the ID, rating, title and fed of the other player but not the player number" do
@@ -249,7 +249,7 @@ module ICU
         @p1.rating.should == 2100
         @p1.title.should == 'IM'
         @p1.fed.should == 'IRL'
-        @p1.fide.should == 2500035
+        @p1.fide_id.should == 2500035
       end
 
       it "should have a kind of symmetry" do

data/spec/tournament_krause_spec.rb

@@ -8,7 +8,7 @@ module ICU
         p = @t.player(num)
         p.first_name.should == first
         p.last_name.should  == last
-        [:gender, :title, :rating, :fide_rating, :fed, :id, :fide, :dob, :rank].each do |key|
+        [:gender, :title, :rating, :fide_rating, :fed, :id, :fide_id, :dob, :rank].each do |key|
           p.send(key).should == other[key] if other.has_key?(key)
         end
       end
@@ -71,9 +71,9 @@ KRAUSE
 
         it "should have players and their details" do
           @t.should have(3).players
-          check_player(1, 'Gearoidin', 'Ui Laighleis', :gender => 'F', :fide_rating => 1985, :fed => 'IRL', :fide =>  2501171, :dob => '1964-06-10', :rank => 2)
-          check_player(2, 'Mark', 'Orr',               :gender => 'M', :fide_rating => 2258, :fed => 'IRL', :fide =>  2500035, :dob => '1955-11-09', :rank => 1, :title => 'IM')
-          check_player(3, 'Viktor', 'Bologan',         :gender => 'M', :fide_rating => 2663, :fed => 'MDA', :fide => 13900048, :dob => '1971-01-01', :rank => 3, :title => 'GM')
+          check_player(1, 'Gearoidin', 'Ui Laighleis', :gender => 'F', :fide_rating => 1985, :fed => 'IRL', :fide_id =>  2501171, :dob => '1964-06-10', :rank => 2)
+          check_player(2, 'Mark', 'Orr',               :gender => 'M', :fide_rating => 2258, :fed => 'IRL', :fide_id =>  2500035, :dob => '1955-11-09', :rank => 1, :title => 'IM')
+          check_player(3, 'Viktor', 'Bologan',         :gender => 'M', :fide_rating => 2663, :fed => 'MDA', :fide_id => 13900048, :dob => '1971-01-01', :rank => 3, :title => 'GM')
         end
 
         it "should have correct results for each player" do
@@ -254,9 +254,9 @@ KRAUSE
 
         it "should have local IDs by default" do
           @t = @p.parse(@krause)
-          check_player(1, 'Gearoidin', 'Ui Laighleis', :id => 2501171, :fide => nil)
-          check_player(2, 'Mark',      'Orr',          :id => 2500035, :fide => nil)
-          check_player(3, 'Viktor',    'Bologan',      :id => nil,     :fide => nil)
+          check_player(1, 'Gearoidin', 'Ui Laighleis', :id => 2501171, :fide_id => nil)
+          check_player(2, 'Mark',      'Orr',          :id => 2500035, :fide_id => nil)
+          check_player(3, 'Viktor',    'Bologan',      :id => nil,     :fide_id => nil)
         end
 
         it "should have FIDE IDs if option is used" do

data/spec/tournament_sp_spec.rb

@@ -11,7 +11,7 @@ module ICU
   class Player
     def sp_signature
       [
-        name, id, fide, rating, fide_rating, points, rank,
+        name, id, fide_id, rating, fide_rating, points, rank,
         results.map{ |r| r.round }.join(''),
         results.map{ |r| r.score }.join(''),
         results.map{ |r| r.colour || "-" }.join(''),

data/spec/tournament_spx_spec.rb

@@ -70,9 +70,9 @@ EXPORT
         end
 
         it "players should have correct FIDE IDs" do
-          @t.player(1).fide.should be_nil
-          @t.player(2).fide.should == 1234568
-          @t.player(3).fide.should == 1234567
+          @t.player(1).fide_id.should be_nil
+          @t.player(2).fide_id.should == 1234568
+          @t.player(3).fide_id.should == 1234567
         end
 
         it "players should have correct ICU ratings" do
@@ -125,7 +125,7 @@ EXPORT
           @t = ICU::Tournament.new(name, start)
           @t.add_player(ICU::Player.new('Bobby', 'Fischer', 10))
           @t.add_player(ICU::Player.new('Garry', 'Kasparov', 20))
-          @t.add_player(ICU::Player.new('Mark', 'Orr', 30, :id => 1350, :fide => 2500035, :fed => 'IRL', :rating => 2200, :fide_rating => 2250))
+          @t.add_player(ICU::Player.new('Mark', 'Orr', 30, :id => 1350, :fide_id => 2500035, :fed => 'IRL', :rating => 2200, :fide_rating => 2250))
           @t.add_result(ICU::Result.new(1, 10, 'D', :opponent => 30))
           @t.add_result(ICU::Result.new(2, 20, 'W', :opponent => 30))
           @t.add_result(ICU::Result.new(3, 20, 'L', :opponent => 10))
@@ -156,11 +156,11 @@ EXPORT
           @x.should match(/^No\s*Name\s*Loc Id\s*Total\s*1\s*2\s*3\s*/)
           @x = @t.serialize('SPExport', :columns => [:points, :id, :fed])
           @x.should match(/^No\s*Name\s*Feder\s*Loc Id\s*Total\s*1\s*2\s*3\s*/)
-          @x = @t.serialize('SPExport', :columns => [:points, :id, :fed, :fed, :rubbish, :fide])
+          @x = @t.serialize('SPExport', :columns => [:points, :id, :fed, :fed, :rubbish, :fide_id])
           @x.should match(/^No\s*Name\s*Feder\s*Intl Id\s*Loc Id\s*Total\s*1\s*2\s*3\s*/)
-          @x = @t.serialize('SPExport', :columns => [:fed, :fide, :points, :id, :rating])
+          @x = @t.serialize('SPExport', :columns => [:fed, :fide_id, :points, :id, :rating])
           @x.should match(/^No\s*Name\s*Feder\s*Intl Id\s*Loc Id\s*Loc\s*Total\s*1\s*2\s*3\s*/)
-          @x = @t.serialize('SPExport', :columns => [:fed, :fide, :fide_rating, :points, :id, :rating])
+          @x = @t.serialize('SPExport', :columns => [:fed, :fide_id, :fide_rating, :points, :id, :rating])
           @x.should match(/^No\s*Name\s*Feder\s*Intl Id\s*Loc Id\s*Rtg\s*Loc\s*Total\s*1\s*2\s*3\s*/)
           @x.should match(/3\s*Orr,\s*Mark\s*IRL\s*2500035\s*1350\s*2250\s*2200\s*0.5\s*1:D\s*2:L\s*:\s*/)
         end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 1
   - 3
-  - 1
-  version: 1.3.1
+  - 2
+  version: 1.3.2
 platform: ruby
 authors: 
 - Mark Orr