icu_tournament 1.4.0 → 1.4.1

data/lib/icu_tournament/tournament_krause.rb

@@ -96,18 +96,22 @@ module ICU
     #
     # By default all available information is output for each player, however, this is customizable. The player number,
     # name, total points and results are always output but any of the remaining data (_gender_, _title_, _rating_ or _fide_rating_,
-    # _fed_, _id_ or _fide_id_, _dob_ and _rank_) can be omitted, if desired, by specifying an array of columns to include.
-    # To omitt all the optional data, supply an empty array:
+    # _fed_, _id_ or _fide_id_, _dob_ and _rank_) can be omitted, if desired, by specifying an array of columns to include
+    # or exclude. To omitt all the optional data, supply an empty array:
     #
-    #   krause = tournament.serialize('Krause', :columns => [])
+    #   krause = tournament.serialize('Krause', :only => [])
     #
-    # To omitt, for example, just federation and rating, include all columns but those two:
+    # To omitt just federation and rating but include all others:
     #
-    #   krause = tournament.serialize('Krause', :columns => [:gender, :title, :id, :dob, :rank])
+    #   krause = tournament.serialize('Krause', :except => [:fed, :rating])
     #
-    # To output FIDE IDs and ratings use the _fide_ option in conjunctions with the _id_ and _rating_ columns:
+    # To include only date of birth and title:
     #
-    #   krause = tournament.serialize('Krause', :columns => [:id, :rating], :fide => true)
+    #   krause = tournament.serialize('Krause', :only => [:dob, :title])
+    #
+    # To output FIDE IDs and ratings use the _fide_ option in conjunctions with the _id_ and _rating_ options:
+    #
+    #   krause = tournament.serialize('Krause', :only => [:gender, :id, :rating], :fide => true)
     #
     # == Parser Strictness
     #
@@ -194,6 +198,17 @@ module ICU
     class Krause
       attr_reader :error, :comments
 
+      OPTIONS =
+      [
+        [:gender,  "Gender"],
+        [:title,    "Title"],
+        [:rating,  "Rating"],
+        [:fed, "Federation"],
+        [:id,          "ID"],
+        [:dob,        "DOB"],
+        [:rank,      "Rank"],
+      ]
+
       # Parse Krause data returning a Tournament on success or raising an exception on error.
       def parse!(krs, arg={})
         @lineno = 0
@@ -500,16 +515,21 @@ module ICU
   class Player
     # Format a player's 001 record as it would appear in a Krause formatted file (including the final newline).
     def to_krause(rounds, arg)
-      default = [:gender, :title, :rating, :fed, :id, :dob, :rank]
+      defaults = ICU::Tournament::Krause::OPTIONS.map(&:first)
 
       # Optional columns.
-      optional = arg[:columns] if arg[:columns].instance_of?(Array)
-      optional.map!(&:to_s).map!(&:to_sym) if optional
-      optional = default.dup unless optional
+      case
+      when arg[:except].instance_of?(Array)
+        optional = (Set.new(defaults) - arg[:except].map!(&:to_s).map!(&:to_sym)).to_a
+      when arg[:only].instance_of?(Array)
+        optional = arg[:only].map!(&:to_s).map!(&:to_sym)
+      else
+        optional = defaults
+      end
       optional = optional.inject({}) { |m, a| m[a] = true; m }
 
       # Get the values to use.
-      val = default.inject({}) do |m, a|
+      val = defaults.inject({}) do |m, a|
         if optional[a]
           if arg[:fide] && (a == :rating || a == :id)
             m[a] = send("fide_#{a}")
@@ -519,7 +539,7 @@ module ICU
         end
         m
       end
-      
+
       # Output the mandatory and optional values.
       krause = '001'
       krause << sprintf(' %4d', @num)
@@ -532,7 +552,7 @@ module ICU
       krause << sprintf(' %10s', val[:dob])
       krause << sprintf(' %4.1f', points)
       krause << sprintf(' %4s', val[:rank])
-      
+
       # And finally the round scores.
       (1..rounds).each do |r|
         result = find_result(r)

data/lib/icu_tournament/tournament_spx.rb

@@ -44,8 +44,11 @@ module ICU
     #   spexport = tournament.serialize('SPExport')
     #
     # In either case the method returns a string representation of the tourament in SwissPerfect export
-    # format with tab separators, space padding and (by default) the local player ID and total score
-    # optional columns:
+    # format with tab separators, space padding and (by default) all the available information about the
+    # players. To customize what is displayed, use the _only_ option and supply an array of symbols or
+    # strings to specify which columns to include. For example:
+    #
+    #   spexport = tournament.serialize('SPExport', :only => [:id, :points])
     #
     #   No  Name                 Loc Id  Total    1     2     3
     #
@@ -54,20 +57,11 @@ module ICU
     #   3   Hulleman, Leon       6409    1       2:L   4:W   1:L
     #   4   Dunne, Thomas        10914   0       1:L   3:L   2:L
     #
-    # To change which optional columns are output, use the _columns_ option with an array of the column attribute names.
     # The optional attribute names, together with their column header names in SwissPerfect, are as follows:
+    # _fed_ (Feder), _fide_id_ (Intl Id), _id_ (Loc Id), _fide_rating_ (Rtg), _rating_ (Loc), _title_ (Title),
+    # _points_: (Total). To omitt the optional columns completely, supply an empty array of column names:
     #
-    # * _fed_: Feder
-    # * _fide_id_: Intl Id
-    # * _id_: Loc Id
-    # * _fide_rating_: Rtg
-    # * _rating_: Loc
-    # * _title_: Title
-    # * _points_: Total
-    #
-    # So, for example, to omitt the optional columns completely, supply an empty array of column names:
-    #
-    #   tournament.serialize('SPExport', :columns => [])
+    #   tournament.serialize('SPExport', :only => [])
     #
     #   No  Name                  1     2     3
     #
@@ -78,19 +72,24 @@ module ICU
     #
     # Or supply whatever columns you want, for example:
     #
-    #   tournament.serialize('SPExport', :columns => [:fide_id, :fide_rating])
+    #   tournament.serialize('SPExport', :only => %w{fide_id fide_rating})
+    #
+    # Or to omitt rather than include, use the logically opposite _except_ option:
+    #
+    #   tournament.serialize('SPExport', :except => [: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.
+    # The order of column names in the _only_ option has no effect.
     #
-    # The default, when you leave out the _columns_ option is equivalent to:
+    # The default, when you leave out the _only_ or _except_ options, is equivalent to both of the following:
     #
-    #   tournament.serialize('SPExport', :columns => [:id, :points])
+    #   tournament.serialize('SPExport', :only => %w{fed fide_id id fide_rating rating title points})
+    #   tournament.serialize('SPExport', :except => [])
     #
     # The order of players in the serialized output is always by player number and as a side effect of serialization,
-    # the player numbers will be adjusted to ensure they range from 1 to the total number of players maintaining the
-    # original order. If you would prefer rank-order instead, then you must first renumber the players by rank (the
-    # default renumbering method) before serializing. For example:
+    # the player numbers will be adjusted to ensure they range from 1 to the total number of players, maintaining the
+    # original order. If you would prefer rank-order instead, then you must first renumber the players by rank before
+    # serializing. For example:
     #
     #   spexport = tournament.renumber(:rank).serialize('SPExport')
     #
@@ -98,7 +97,7 @@ module ICU
     #
     #   spexport = tournament.renumber.serialize('SPExport')
     #
-    # You may wish set the tie-break rules before ranking:
+    # You may wish to set the tie-break rules before ranking:
     #
     #   tournament.tie_breaks = [:buchholz, :neustadtl]
     #   spexport = tournament.rerank.renumber.serialize('SwissPerfect')
@@ -197,15 +196,22 @@ module ICU
         rounds = t.last_round
 
         # Optional columns.
-        optional = arg[:columns] if arg[:columns].instance_of?(Array)
-        optional = [:id, :points] unless optional
-        optional.map!(&:to_s).map!(&:to_sym)
+        defaults = COLUMNS.map(&:first)
+        case
+        when arg[:except].instance_of?(Array)
+          optional = (Set.new(defaults) - arg[:except].map!(&:to_s).map!(&:to_sym)).to_a
+        when arg[:only].instance_of?(Array)
+          optional = arg[:only].map!(&:to_s).map!(&:to_sym)
+        else
+          optional = defaults
+        end
+        optional = optional.inject({}) { |m, a| m[a] = true; m }
 
         # Columns identifiers in SwissPerfect order.
         columns = Array.new
         columns.push(:num)
         columns.push(:name)
-        COLUMNS.map(&:first).each { |x| columns.push(x) if optional.include?(x) && x != :num && x != :name }
+        defaults.each { |x| columns.push(x) if optional[x] && x != :num && x != :name }
 
         # Widths and formats for each column.
         width = Hash.new

data/lib/icu_tournament/version.rb

@@ -2,6 +2,6 @@
 
 module ICU
   class Tournament
-    VERSION = "1.4.0"
+    VERSION = "1.4.1"
   end
 end

data/spec/tournament_krause_spec.rb

@@ -349,33 +349,41 @@ KRAUSE
           text.should match(/001    3    g Svidler,Peter                          RUS             1971-01-01  0.0    3/)
         end
 
-        it "should omitt all optional data if columns option is an empty hash" do
-          text = @t.serialize('Krause', :columns => [])
+        it "should omitt all optional data if the :only option is an empty hash" do
+          text = @t.serialize('Krause', :only => [])
           text.should match(/001    1      Ui Laighleis,Gearoidin                                             1.0     /)
           text.should match(/001    2      Orr,Mark                                                           2.0     /)
           text.should match(/001    3      Svidler,Peter                                                      0.0     /)
         end
 
         it "should should be able to include a subset of attributes, test 1" do
-          text = @t.serialize('Krause', :columns => [:gender, "dob", :id, "rubbish"])
+          text = @t.serialize('Krause', :only => [:gender, "dob", :id, "rubbish"])
           text.should match(/001    1 w    Ui Laighleis,Gearoidin                            3364 1964-06-10  1.0     /)
           text.should match(/001    2      Orr,Mark                                          1350 1955-11-09  2.0     /)
           text.should match(/001    3      Svidler,Peter                                    16790 1971-01-01  0.0     /)
         end
 
         it "should should be able to include a subset of attributes, test 2" do
-          text = @t.serialize('Krause', :columns => [:rank, "title", :fed, "rating"])
+          text = @t.serialize('Krause', :only => [:rank, "title", :fed, "rating"])
           text.should match(/001    1      Ui Laighleis,Gearoidin            1985 IRL                         1.0    2/)
           text.should match(/001    2    m Orr,Mark                          2258 IRL                         2.0    1/)
           text.should match(/001    3    g Svidler,Peter                     2663 RUS                         0.0    3/)
         end
 
         it "should should be able to include all attributes" do
-          text = @t.serialize('Krause', :columns => [:gender, :title, :rating, :fed, :id, :dob, :rank])
+          text = @t.serialize('Krause', :only => [:gender, :title, :rating, :fed, :id, :dob, :rank])
           text.should match(/001    1 w    Ui Laighleis,Gearoidin            1985 IRL        3364 1964-06-10  1.0    2/)
           text.should match(/001    2    m Orr,Mark                          2258 IRL        1350 1955-11-09  2.0    1/)
           text.should match(/001    3    g Svidler,Peter                     2663 RUS       16790 1971-01-01  0.0    3/)
         end
+        
+        it "the :only and :except options are logical opposites" do
+          @t.serialize('Krause', :only => [:gender, :title, :rating]).should == @t.serialize('Krause', :except => [:fed, :id, "dob", :rank])
+          @t.serialize('Krause', :only => [:gender]).should == @t.serialize('Krause', :except => [:fed, :id, :dob, :rank, :title, :rating])
+          @t.serialize('Krause', :only => [:gender, :title, "rating", :fed, :id, :dob]).should == @t.serialize('Krause', :except => [:rank])
+          @t.serialize('Krause', :only => [:gender, :title, :rating, :fed, "id", :dob, :rank]).should == @t.serialize('Krause', :except => [])
+          @t.serialize('Krause', :only => []).should == @t.serialize('Krause', :except => [:gender, :title, :rating, :fed, :id, :dob, :rank])
+        end
       end
 
       context "customised serialisation with FIDE IDs" do
@@ -406,29 +414,29 @@ KRAUSE
           text.should match(/001    3    g Svidler,Peter                          RUS             1971-01-01  0.0    3/)
         end
 
-        it "should omitt all optional data if columns option is an empty hash" do
-          text = @t.serialize('Krause', :columns => [])
+        it "should omitt all optional data if the :only option is an empty hash" do
+          text = @t.serialize('Krause', :only => [])
           text.should match(/001    1      Ui Laighleis,Gearoidin                                             1.0     /)
           text.should match(/001    2      Orr,Mark                                                           2.0     /)
           text.should match(/001    3      Svidler,Peter                                                      0.0     /)
         end
 
         it "should should be able to include a subset of attributes, test 1" do
-          text = @t.serialize('Krause', :columns => [:gender, "dob", :id], :fide => true)
+          text = @t.serialize('Krause', :only => [:gender, "dob", :id], :fide => true)
           text.should match(/001    1 w    Ui Laighleis,Gearoidin                         2501171 1964-06-10  1.0     /)
           text.should match(/001    2      Orr,Mark                                       2500035 1955-11-09  2.0     /)
           text.should match(/001    3      Svidler,Peter                                  4102142 1971-01-01  0.0     /)
         end
 
         it "should should be able to include a subset of attributes, test 2" do
-          text = @t.serialize('Krause', :columns => [:rank, "title", :fed, "rating", :rubbish], :fide => true)
+          text = @t.serialize('Krause', :only => [:rank, "title", :fed, "rating", :rubbish], :fide => true)
           text.should match(/001    1      Ui Laighleis,Gearoidin            1985 IRL                         1.0    2/)
           text.should match(/001    2    m Orr,Mark                          2258 IRL                         2.0    1/)
           text.should match(/001    3    g Svidler,Peter                     2663 RUS                         0.0    3/)
         end
 
         it "should should be able to include all attributes" do
-          text = @t.serialize('Krause', :columns => [:gender, :title, :rating, :fed, :id, :dob, :rank], :fide => true)
+          text = @t.serialize('Krause', :only => [:gender, :title, :rating, :fed, :id, :dob, :rank], :fide => true)
           text.should match(/001    1 w    Ui Laighleis,Gearoidin            1985 IRL     2501171 1964-06-10  1.0    2/)
           text.should match(/001    2    m Orr,Mark                          2258 IRL     2500035 1955-11-09  2.0    1/)
           text.should match(/001    3    g Svidler,Peter                     2663 RUS     4102142 1971-01-01  0.0    3/)

data/spec/tournament_sp_spec.rb

@@ -58,7 +58,7 @@ module ICU
         end
 
         it "should serialize to the text export format" do
-          @t.serialize('SPExport').should == @s
+          @t.serialize('SPExport', :only => [:id, :points]).should == @s
         end
       end
 
@@ -90,7 +90,7 @@ module ICU
         end
 
         it "should serialize to the text export format" do
-          @t.rerank.renumber.serialize('SPExport').should == @s
+          @t.rerank.renumber.serialize('SPExport', :only => [:id, :points]).should == @s
         end
       end
 

data/spec/tournament_spx_spec.rb

@@ -142,28 +142,37 @@ EXPORT
           @r.player(3).spx_signature.should == "Orr, Mark|1350|0.5|123|DLL|---|TTF"
         end
 
-        it "should have default columns" do
-          @x.should match(/^No\s*Name\s*Loc Id\s*Total\s*1\s*2\s*3\s*/)
+        it "should show all columns by default" do
+          @x.should match(/^No\s*Name\s*Feder\s*Intl Id\s*Loc Id\s*Rtg\s*Loc\s*Title\s*Total\s*1\s*2\s*3\s*/)
           @x.should match(/1\s*Fischer,\s*Bobby\s*1\.5\s*3:D\s*0?:L?\s*2:W\s*/)
         end
 
         it "can have custom columns" do
-          @x = @t.serialize('SPExport', :columns => [])
+          @x = @t.serialize('SPExport', :only => [])
           @x.should match(/^No\s*Name\s*1\s*2\s*3\s*/)
-          @x = @t.serialize('SPExport', :columns => [:points])
+          @x = @t.serialize('SPExport', :only => [:points])
           @x.should match(/^No\s*Name\s*Total\s*1\s*2\s*3\s*/)
-          @x = @t.serialize('SPExport', :columns => [:points, :id])
+          @x = @t.serialize('SPExport', :only => [:points, :id])
           @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 = @t.serialize('SPExport', :only => [: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_id])
+          @x = @t.serialize('SPExport', :only => [: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_id", :points, :id, :rating])
+          @x = @t.serialize('SPExport', :only => [: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_id, :fide_rating, :points, :id, :rating])
+          @x = @t.serialize('SPExport', :only => [: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
+
+        it "the :only and :except options are logical opposites" do
+          @t.serialize('SPExport', :only => [:points, :id, "fed"]).should == @t.serialize('SPExport', :except => [:fide_id, :rating, "fide_rating", :title])
+          @t.serialize('SPExport', :only => ["points"]).should == @t.serialize('SPExport', :except => ["fide_id", :rating, :fide_rating, :title, :id, :fed])
+          @t.serialize('SPExport', :only => [:rating, :fide_rating, :title, :id, :fed, :points]).should == @t.serialize('SPExport', :except => [:fide_id])
+          @t.serialize('SPExport', :only => %w{rating fide_rating fide_id title id fed points}).should == @t.serialize('SPExport', :except => [])
+          @t.serialize('SPExport', :only => []).should == @t.serialize('SPExport', :except => [:rating, :fide_rating, :fide_id, :title, :id, :fed, :points])
+          @t.serialize('SPExport', :except => []).should == @t.serialize('SPExport')
+        end
       end
 
       context "invisible bonuses" do

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 1
   - 4
-  - 0
-  version: 1.4.0
+  - 1
+  version: 1.4.1
 platform: ruby
 authors: 
 - Mark Orr