icu_tournament 1.7.3 → 1.8.0

data/lib/icu_tournament/player.rb

@@ -97,7 +97,7 @@ module ICU
   #   fox1.gender                      # => 'M'
   #
   class Player
-    extend ICU::Accessor
+    extend ICU::Util::Accessor
     attr_integer :num
     attr_positive_or_nil :id, :fide_id, :rating, :fide_rating, :rank
     attr_date_or_nil :dob
@@ -132,7 +132,7 @@ module ICU
 
     # Reset the original name.
     def original_name=(original_name)
-      @original_name = ICU::Util.to_utf8(original_name)
+      @original_name = ICU::Util::String.to_utf8(original_name)
     end
 
     # Return the full name, last name first.

data/lib/icu_tournament/result.rb

@@ -80,7 +80,7 @@ module ICU
   #   r.eql?(r3, :except => [:rateable, :score])   # => true
   #
   class Result
-    extend ICU::Accessor
+    extend ICU::Util::Accessor
     attr_positive :round
     attr_integer :player
 

data/lib/icu_tournament/tournament.rb

@@ -193,7 +193,7 @@ module ICU
   # in which case any options supplied to this method will be silently ignored.
   #
   class Tournament
-    extend ICU::Accessor
+    extend ICU::Util::Accessor
     attr_date :start
     attr_date_or_nil :finish
     attr_positive_or_nil :rounds
@@ -224,7 +224,7 @@ module ICU
     # Add a round date.
     def add_round_date(round_date)
       round_date = round_date.to_s.strip
-      parsed_date = Util.parsedate(round_date)
+      parsed_date = Util::Date.parse(round_date)
       raise "invalid round date (#{round_date})" unless parsed_date
       @round_dates << parsed_date
     end

data/lib/icu_tournament/tournament_fcsv.rb

@@ -125,7 +125,7 @@ module ICU
       def parse!(csv, arg={})
         @state, @line, @round, @sum, @error = 0, 0, nil, nil, nil
         @tournament = Tournament.new('Unspecified', '2000-01-01')
-        csv = ICU::Util.to_utf8(csv) unless arg[:is_utf8]
+        csv = ICU::Util::String.to_utf8(csv) unless arg[:is_utf8]
 
         CSV.parse(csv, :row_sep => :auto) do |r|
           @line += 1                            # increment line number
@@ -184,7 +184,7 @@ module ICU
 
       # Same as <em>parse!</em> except the input is a file name rather than file contents.
       def parse_file!(file)
-        csv = ICU::Util.read_utf8(file)
+        csv = ICU::Util::File.read_utf8(file)
         parse!(csv, :is_utf8 => true)
       end
 

data/lib/icu_tournament/tournament_krause.rb

@@ -216,7 +216,7 @@ module ICU
         @name_set, @start_set = false, false
         @comments = ''
         @results = Array.new
-        krs = ICU::Util.to_utf8(krs) unless arg[:is_utf8]
+        krs = ICU::Util::String.to_utf8(krs) unless arg[:is_utf8]
         lines = get_lines(krs)
 
         # Process all lines.
@@ -292,7 +292,7 @@ module ICU
 
       # Same as <em>parse!</em> except the input is a file name rather than file contents.
       def parse_file!(file, arg={})
-        krause = ICU::Util.read_utf8(file)
+        krause = ICU::Util::File.read_utf8(file)
         arg[:is_utf8] = true
         parse!(krause, arg)
       end

data/lib/icu_tournament/tournament_sp.rb

@@ -185,7 +185,7 @@ module ICU
 
       def parse_ini(file)
         begin
-          ini = ICU::Util.load_ini(file)
+          ini = ICU::Util::File.load_ini(file)
         rescue
           raise "non-existant INI file (#{file})"
         end

data/lib/icu_tournament/tournament_spx.rb

@@ -128,7 +128,7 @@ module ICU
         @lineno = 0
         @header = nil
         @results = Array.new
-        spx = ICU::Util.to_utf8(spx) unless arg[:is_utf8]
+        spx = ICU::Util::String.to_utf8(spx) unless arg[:is_utf8]
 
         # Process each line.
         spx.each_line do |line|
@@ -172,7 +172,7 @@ module ICU
 
       # Same as <em>parse!</em> except the input is a file name rather than file contents.
       def parse_file!(file, arg={})
-        spx = ICU::Util.read_utf8(file)
+        spx = ICU::Util::File.read_utf8(file)
         arg[:is_utf8] = true
         parse!(spx, arg)
       end

data/lib/icu_tournament/util.rb

@@ -1,166 +1,167 @@
 module ICU
   module Util
-
-    # 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 and 1.9.
-    # In 1.8 it assumes American dates and will raise ArgumentError on "30/03/2003".
-    # In 1.9 it assumes European dates and will raise ArgumentError on "03/30/2003".
-    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
+    module Date
+      # Parse dates into yyyy-mm-dd format, preferring European over US convention. Returns nil on error.
+      #
+      #   Date.parse('1955-11-09')       # => '1955-11-09'
+      #   Date.parse('02/03/2009')       # => '2009-03-02'
+      #   Date.parse('02/23/2009')       # => '2009-02-23'
+      #   Date.parse('16th June 1986')   # => '1986-06-16'
+      #
+      # Note that the parse method of the Date class behaves differently in Ruby 1.8 and 1.9.
+      # In 1.8 it assumes American dates and will raise ArgumentError on "30/03/2003".
+      # In 1.9 it assumes European dates and will raise ArgumentError on "03/30/2003".
+      def self.parse(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
 
-    # Read UTF data from a file.
-    def self.read_utf8(name)
-      File.open(name, "r:ASCII-8BIT") do |f|
-        data = f.read
-        bom = "\xEF\xBB\xBF".force_encoding("ASCII-8BIT")
-        data.sub!(/^#{bom}/, "")  # get rid of a UTF-8 BOM
-        to_utf8(data)             # this function is defined in ICU::Util from icu_name
+    module File
+      # Read UTF data from a file.
+      def self.read_utf8(name)
+        ::File.open(name, "r:ASCII-8BIT") do |f|
+          data = f.read
+          bom = "\xEF\xBB\xBF".force_encoding("ASCII-8BIT")
+          data.sub!(/^#{bom}/, "")         # get rid of a UTF-8 BOM
+          ICU::Util::String.to_utf8(data)  # defined in icu_name
+        end
       end
-    end
 
-    # Load an INI file and convert to a hash.
-    def self.load_ini(name)
-      text = read_utf8(name)
-      data = Hash.new
-      header = nil
-      text.split(/\n/).each do |line|
-        if line.match(/^\s*\[([^\]]+)\]\s*$/)
-          header = $1.strip
-          header = nil if header == ""
-        elsif header && line.match(/^([^=]+)=(.*)$/)
-          key = $1.strip
-          val = $2.strip
-          unless key == ""
-            data[header] ||= Hash.new
-            data[header][key] = val
+      # Load an INI file and convert to a hash.
+      def self.load_ini(name)
+        text = self.read_utf8(name)
+        data = Hash.new
+        header = nil
+        text.split(/\n/).each do |line|
+          if line.match(/^\s*\[([^\]]+)\]\s*$/)
+            header = $1.strip
+            header = nil if header == ""
+          elsif header && line.match(/^([^=]+)=(.*)$/)
+            key = $1.strip
+            val = $2.strip
+            unless key == ""
+              data[header] ||= Hash.new
+              data[header][key] = val
+            end
           end
         end
+        data
       end
-      data
     end
-  end
 
-  #
-  # Miscellaneous accessor helpers.
-  #
-  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)
+    # Miscellaneous accessor helpers.
+    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
-    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
+      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
-    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
+      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
-          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
+      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
-    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
+      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
-          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
+      def attr_date(*names)
+        names.each do |name|
+          attr_accessor(name) do |val|
+            tmp = val.to_s.strip
+            tmp = ICU::Util::Date::parse(tmp)
+            raise "invalid date (#{val}) for #{name}" unless tmp
+            tmp
+          end
         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
+      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::Date::parse(tmp)
+              raise "invalid date or nil (#{val}) for #{name}" unless tmp
+            end
+            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
+      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
-    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
+      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

data/lib/icu_tournament/version.rb

@@ -2,6 +2,6 @@
 
 module ICU
   class Tournament
-    VERSION = "1.7.3"
+    VERSION = "1.8.0"
   end
 end

data/spec/util_spec.rb

@@ -2,430 +2,434 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 module ICU
-  describe Util do
-    context "#parsedate" do
-      it "should parse standard dates" do
-        Util.parsedate('2001-01-01').should == '2001-01-01'
-        Util.parsedate('1955-11-09').should == '1955-11-09'
-      end
-
-      it "should handle US format" do
-        Util.parsedate('03/30/2009').should == '2009-03-30'
-      end
-
-      it "should handle European format" do
-        Util.parsedate('30/03/2009').should == '2009-03-30'
-      end
-
-      it "should prefer European format" do
-        Util.parsedate('02/03/2009').should == '2009-03-02'
-      end
-
-      it "should handle US style when there's no alternative" do
-        Util.parsedate('02/23/2009').should == '2009-02-23'
-      end
-
-      it "should handle single digits" do
-        Util.parsedate('9/8/2006').should == '2006-08-09'
-      end
-
-      it "should handle names of monthsx" do
-        Util.parsedate('9th Nov 1955').should == '1955-11-09'
-        Util.parsedate('16th June 1986').should == '1986-06-16'
+  module Util
+    describe Date do
+      context "#parse" do
+        it "should parse standard dates" do
+          Date.parse('2001-01-01').should == '2001-01-01'
+          Date.parse('1955-11-09').should == '1955-11-09'
+        end
+    
+        it "should handle US format" do
+          Date.parse('03/30/2009').should == '2009-03-30'
+        end
+    
+        it "should handle European format" do
+          Date.parse('30/03/2009').should == '2009-03-30'
+        end
+    
+        it "should prefer European format" do
+          Date.parse('02/03/2009').should == '2009-03-02'
+        end
+    
+        it "should handle US style when there's no alternative" do
+          Date.parse('02/23/2009').should == '2009-02-23'
+        end
+    
+        it "should handle single digits" do
+          Date.parse('9/8/2006').should == '2006-08-09'
+        end
+    
+        it "should handle names of monthsx" do
+          Date.parse('9th Nov 1955').should == '1955-11-09'
+          Date.parse('16th June 1986').should == '1986-06-16'
+        end
       end
     end
+    
+    describe File do
+      context "#read_utf8" do
+        before(:all) do
+          @s = ::File.dirname(__FILE__) + '/samples/file'
+        end
 
-    context "#read_utf8" do
-      before(:all) do
-        @s = File.dirname(__FILE__) + '/samples/file'
-      end
-
-      it "should read ASCII" do
-        Util.read_utf8("#{@s}/ascii.txt").should == "Resume\nResume\n"
-      end
+        it "should read ASCII" do
+          File.read_utf8("#{@s}/ascii.txt").should == "Resume\nResume\n"
+        end
 
-      it "should read Latin-1" do
-        Util.read_utf8("#{@s}/latin1.txt").should == "Résumé\nRésumé\n"
-      end
+        it "should read Latin-1" do
+          File.read_utf8("#{@s}/latin1.txt").should == "Résumé\nRésumé\n"
+        end
 
-      it "should read Windows CP1252" do
-        Util.read_utf8("#{@s}/cp1252.txt").should == "€3\n£7\n¥1\n"
-      end
+        it "should read Windows CP1252" do
+          File.read_utf8("#{@s}/cp1252.txt").should == "€3\n£7\n¥1\n"
+        end
 
-      it "should read UTF-8" do
-        Util.read_utf8("#{@s}/utf8.txt").should == "ヒラガナ\nヒラガナ\n"
-      end
+        it "should read UTF-8" do
+          File.read_utf8("#{@s}/utf8.txt").should == "ヒラガナ\nヒラガナ\n"
+        end
 
-      it "should thow an exception for a non-existant file" do
-        lambda { Util.read_utf8("#{@s}/no_such_file.txt") }.should raise_error
+        it "should thow an exception for a non-existant file" do
+          lambda { File.read_utf8("#{@s}/no_such_file.txt") }.should raise_error
+        end
       end
-    end
 
-    context "#load_ini" do
-      before(:all) do
-        @s = File.dirname(__FILE__) + '/samples/ini'
-      end
+      context "#load_ini" do
+        before(:all) do
+          @s = ::File.dirname(__FILE__) + '/samples/ini'
+        end
 
-      it "should read ASCII" do
-        data = Util.load_ini("#{@s}/ascii.ini")
-        data.should be_an_instance_of(Hash)
-        data["Pairing"]["UseRating"].should == "0"
-        data["NoKeys"] == nil
-        data["Tournament Info"]["Arbiter"].should == "Herbert Scarry"
-        data["Tournament Info"]["DrawSymbol"].should == "D"
-      end
+        it "should read ASCII" do
+          data = File.load_ini("#{@s}/ascii.ini")
+          data.should be_an_instance_of(Hash)
+          data["Pairing"]["UseRating"].should == "0"
+          data["NoKeys"] == nil
+          data["Tournament Info"]["Arbiter"].should == "Herbert Scarry"
+          data["Tournament Info"]["DrawSymbol"].should == "D"
+        end
 
-      it "should read Latin1" do
-        data = Util.load_ini("#{@s}/latin1.ini")
-        data.should be_an_instance_of(Hash)
-        data["Tournament Info"]["Arbiter"].should == "Gearóidín"
-        data["Tournament Info"]["DrawSymbol"].should == "½"
-      end
+        it "should read Latin1" do
+          data = File.load_ini("#{@s}/latin1.ini")
+          data.should be_an_instance_of(Hash)
+          data["Tournament Info"]["Arbiter"].should == "Gearóidín"
+          data["Tournament Info"]["DrawSymbol"].should == "½"
+        end
 
-      it "should read Windows-1252" do
-        data = Util.load_ini("#{@s}/cp1252.ini")
-        data.should be_an_instance_of(Hash)
-        data["Tournament Info"]["Entry Fee"].should == "€50"
-      end
+        it "should read Windows-1252" do
+          data = File.load_ini("#{@s}/cp1252.ini")
+          data.should be_an_instance_of(Hash)
+          data["Tournament Info"]["Entry Fee"].should == "€50"
+        end
 
-      it "should read UTF8" do
-        data = Util.load_ini("#{@s}/utf8.ini")
-        data.should be_an_instance_of(Hash)
-        data["Tournament Info"]["Entry Fee"].should == "€50"
-        data["Tournament Info"]["Arbiter"].should == "ヒラガナ"
-        data["Tournament Info"]["DrawSymbol"].should == "½"
-      end
+        it "should read UTF8" do
+          data = File.load_ini("#{@s}/utf8.ini")
+          data.should be_an_instance_of(Hash)
+          data["Tournament Info"]["Entry Fee"].should == "€50"
+          data["Tournament Info"]["Arbiter"].should == "ヒラガナ"
+          data["Tournament Info"]["DrawSymbol"].should == "½"
+        end
 
-      it "should handle untidily formatted files" do
-        data = Util.load_ini("#{@s}/untidy.ini")
-        data.should be_an_instance_of(Hash)
-        data["Tournament Info"]["Entry Fee"].should == "€50"
-        data["Tournament Info"]["DrawSymbol"].should == "½"
-        data["Pairing"]["Use  Rating"].should == "0"
-      end
+        it "should handle untidily formatted files" do
+          data = File.load_ini("#{@s}/untidy.ini")
+          data.should be_an_instance_of(Hash)
+          data["Tournament Info"]["Entry Fee"].should == "€50"
+          data["Tournament Info"]["DrawSymbol"].should == "½"
+          data["Pairing"]["Use  Rating"].should == "0"
+        end
 
-      it "should thow an exception for a non-existant file" do
-        lambda { Util.read_utf8("#{@s}/no_such_file.ini") }.should raise_error
+        it "should thow an exception for a non-existant file" do
+          lambda { File.read_utf8("#{@s}/no_such_file.ini") }.should raise_error
+        end
       end
     end
-  end
 
-  describe Accessor do
-    context "#attr_accessor" do
-      before(:each) do
-        @class = Class.new
-        @class.extend ICU::Accessor
-        @obj = @class.new
-      end
+    describe Accessor do
+      context "#attr_accessor" do
+        before(:each) do
+          @class = Class.new
+          @class.extend ICU::Util::Accessor
+          @obj = @class.new
+        end
 
-      it "should not have an accessor unless declared" do
-        @obj.respond_to?(:myatr).should be_false
-        @obj.respond_to?(:myatr=).should be_false
-      end
+        it "should not have an accessor unless declared" do
+          @obj.respond_to?(:myatr).should be_false
+          @obj.respond_to?(:myatr=).should be_false
+        end
 
-      it "should have a getter but no setter with the default declaration" do
-        @class.attr_accessor('myatr')
-        @obj.respond_to?(:myatr).should be_true
-        @obj.respond_to?(:myatr=).should be_false
-        @obj.instance_eval { @myatr = 42 }
-        @obj.myatr.should == 42
-      end
+        it "should have a getter but no setter with the default declaration" do
+          @class.attr_accessor('myatr')
+          @obj.respond_to?(:myatr).should be_true
+          @obj.respond_to?(:myatr=).should be_false
+          @obj.instance_eval { @myatr = 42 }
+          @obj.myatr.should == 42
+        end
 
-      it "should be able to create do-it-yourself setters such as for a positive integer" do
-        @class.attr_accessor('myatr') do |val|
-          tmp = val.to_i
-          raise "invalid positive integer (#{val})" unless tmp > 0
-          tmp
-        end
-        @obj.respond_to?(:myatr).should be_true
-        @obj.respond_to?(:myatr=).should be_true
-        lambda { @obj.myatr = "no number here" }.should raise_error(/invalid positive integer \(no number here\)/)
-        lambda { @obj.myatr = -1 }.should raise_error
-        lambda { @obj.myatr = 0 }.should raise_error
-        lambda { @obj.myatr = 1 }.should_not raise_error
-        @obj.myatr.should == 1
-        lambda { @obj.myatr = '42' }.should_not raise_error
-        @obj.myatr.should == 42
-        lambda { @obj.myatr = '  0371  ' }.should_not raise_error
-        @obj.myatr.should == 371
+        it "should be able to create do-it-yourself setters such as for a positive integer" do
+          @class.attr_accessor('myatr') do |val|
+            tmp = val.to_i
+            raise "invalid positive integer (#{val})" unless tmp > 0
+            tmp
+          end
+          @obj.respond_to?(:myatr).should be_true
+          @obj.respond_to?(:myatr=).should be_true
+          lambda { @obj.myatr = "no number here" }.should raise_error(/invalid positive integer \(no number here\)/)
+          lambda { @obj.myatr = -1 }.should raise_error
+          lambda { @obj.myatr = 0 }.should raise_error
+          lambda { @obj.myatr = 1 }.should_not raise_error
+          @obj.myatr.should == 1
+          lambda { @obj.myatr = '42' }.should_not raise_error
+          @obj.myatr.should == 42
+          lambda { @obj.myatr = '  0371  ' }.should_not raise_error
+          @obj.myatr.should == 371
+        end
       end
-    end
 
-    context "#attr_integer" do
-      before(:each) do
-        @class = Class.new
-        @class.extend ICU::Accessor
-        @class.attr_integer :myint
-        @obj = @class.new
-      end
+      context "#attr_integer" do
+        before(:each) do
+          @class = Class.new
+          @class.extend ICU::Util::Accessor
+          @class.attr_integer :myint
+          @obj = @class.new
+        end
 
-      it "should have a getter and setter" do
-        @obj.respond_to?(:myint).should be_true
-        @obj.respond_to?(:myint=).should be_true
-      end
+        it "should have a getter and setter" do
+          @obj.respond_to?(:myint).should be_true
+          @obj.respond_to?(:myint=).should be_true
+        end
 
-      it "should work with ints" do
-        @obj.myint = -43
-        @obj.myint.should == -43
-      end
+        it "should work with ints" do
+          @obj.myint = -43
+          @obj.myint.should == -43
+        end
 
-      it "should work with strings" do
-        @obj.myint = "  -99 "
-        @obj.myint.should == -99
-      end
+        it "should work with strings" do
+          @obj.myint = "  -99 "
+          @obj.myint.should == -99
+        end
 
-      it "should handle zero" do
-        lambda { @obj.myint = 0 }.should_not raise_error
-        lambda { @obj.myint = '0' }.should_not raise_error
-      end
+        it "should handle zero" do
+          lambda { @obj.myint = 0 }.should_not raise_error
+          lambda { @obj.myint = '0' }.should_not raise_error
+        end
 
-      it "should reject nil and other non-numbers" do
-        lambda { @obj.myint = nil }.should raise_error(/invalid/)
-        lambda { @obj.myint = "N" }.should raise_error(/invalid/)
-        lambda { @obj.myint = " " }.should raise_error(/invalid/)
-        lambda { @obj.myint = ''  }.should raise_error(/invalid/)
-      end
+        it "should reject nil and other non-numbers" do
+          lambda { @obj.myint = nil }.should raise_error(/invalid/)
+          lambda { @obj.myint = "N" }.should raise_error(/invalid/)
+          lambda { @obj.myint = " " }.should raise_error(/invalid/)
+          lambda { @obj.myint = ''  }.should raise_error(/invalid/)
+        end
 
-      it "should handle multiple names" do
-        @class.attr_integer :yourint, :hisint
-        @obj.respond_to?(:yourint).should be_true
-        @obj.respond_to?(:hisint=).should be_true
+        it "should handle multiple names" do
+          @class.attr_integer :yourint, :hisint
+          @obj.respond_to?(:yourint).should be_true
+          @obj.respond_to?(:hisint=).should be_true
+        end
       end
-    end
 
-    context "#attr_integer_or_nil" do
-      before(:each) do
-        @class = Class.new
-        @class.extend ICU::Accessor
-        @class.attr_integer_or_nil :myint
-        @obj = @class.new
-      end
+      context "#attr_integer_or_nil" do
+        before(:each) do
+          @class = Class.new
+          @class.extend ICU::Util::Accessor
+          @class.attr_integer_or_nil :myint
+          @obj = @class.new
+        end
 
-      it "should have a getter and setter" do
-        @obj.respond_to?(:myint).should be_true
-        @obj.respond_to?(:myint=).should be_true
-      end
+        it "should have a getter and setter" do
+          @obj.respond_to?(:myint).should be_true
+          @obj.respond_to?(:myint=).should be_true
+        end
 
-      it "should work with ints and nil and spaces" do
-        @obj.myint = 43
-        @obj.myint.should == 43
-        @obj.myint = nil
-        @obj.myint.should == nil
-        @obj.myint = '  '
-        @obj.myint.should == nil
-      end
+        it "should work with ints and nil and spaces" do
+          @obj.myint = 43
+          @obj.myint.should == 43
+          @obj.myint = nil
+          @obj.myint.should == nil
+          @obj.myint = '  '
+          @obj.myint.should == nil
+        end
 
-      it "should reject non-numbers" do
-        lambda { @obj.myint = "N" }.should raise_error(/invalid/)
-      end
+        it "should reject non-numbers" do
+          lambda { @obj.myint = "N" }.should raise_error(/invalid/)
+        end
 
-      it "should handle multiple names" do
-        @class.attr_integer :yourint, :hisint
-        @obj.respond_to?(:yourint).should be_true
-        @obj.respond_to?(:hisint=).should be_true
+        it "should handle multiple names" do
+          @class.attr_integer :yourint, :hisint
+          @obj.respond_to?(:yourint).should be_true
+          @obj.respond_to?(:hisint=).should be_true
+        end
       end
-    end
 
-    context "#attr_positive" do
-      before(:each) do
-        @class = Class.new
-        @class.extend ICU::Accessor
-        @class.attr_positive :mypos
-        @obj = @class.new
-      end
+      context "#attr_positive" do
+        before(:each) do
+          @class = Class.new
+          @class.extend ICU::Util::Accessor
+          @class.attr_positive :mypos
+          @obj = @class.new
+        end
 
-      it "should have a getter and setter" do
-        @obj.respond_to?(:mypos).should be_true
-        @obj.respond_to?(:mypos=).should be_true
-      end
+        it "should have a getter and setter" do
+          @obj.respond_to?(:mypos).should be_true
+          @obj.respond_to?(:mypos=).should be_true
+        end
 
-      it "should work as expected" do
-        @obj.mypos = "34"
-        @obj.mypos.should == 34
-      end
+        it "should work as expected" do
+          @obj.mypos = "34"
+          @obj.mypos.should == 34
+        end
 
-      it "should reject nil and other non-positive integers" do
-        lambda { @obj.mypos = nil }.should raise_error(/invalid/)
-        lambda { @obj.mypos = 'X' }.should raise_error(/invalid/)
-        lambda { @obj.mypos = '0' }.should raise_error(/invalid/)
-        lambda { @obj.mypos = -13 }.should raise_error(/invalid/)
-      end
+        it "should reject nil and other non-positive integers" do
+          lambda { @obj.mypos = nil }.should raise_error(/invalid/)
+          lambda { @obj.mypos = 'X' }.should raise_error(/invalid/)
+          lambda { @obj.mypos = '0' }.should raise_error(/invalid/)
+          lambda { @obj.mypos = -13 }.should raise_error(/invalid/)
+        end
 
-      it "should handle multiple names" do
-        @class.attr_integer :ourpos, :theirpos
-        @obj.respond_to?(:ourpos).should be_true
-        @obj.respond_to?(:theirpos=).should be_true
+        it "should handle multiple names" do
+          @class.attr_integer :ourpos, :theirpos
+          @obj.respond_to?(:ourpos).should be_true
+          @obj.respond_to?(:theirpos=).should be_true
+        end
       end
-    end
 
-    context "#attr_positive_or_nil" do
-      before(:each) do
-        @class = Class.new
-        @class.extend ICU::Accessor
-        @class.attr_positive_or_nil :mypon
-        @obj = @class.new
-      end
+      context "#attr_positive_or_nil" do
+        before(:each) do
+          @class = Class.new
+          @class.extend ICU::Util::Accessor
+          @class.attr_positive_or_nil :mypon
+          @obj = @class.new
+        end
 
-      it "should have a getter and setter" do
-        @obj.respond_to?(:mypon).should be_true
-        @obj.respond_to?(:mypon=).should be_true
-      end
+        it "should have a getter and setter" do
+          @obj.respond_to?(:mypon).should be_true
+          @obj.respond_to?(:mypon=).should be_true
+        end
 
-      it "should work with numbers, nil, empty strings and spaces" do
-        @obj.mypon = " 54 "
-        @obj.mypon.should == 54
-        @obj.mypon = nil
-        @obj.mypon.should be_nil
-        @obj.mypon = ''
-        @obj.mypon.should be_nil
-        @obj.mypon = '  '
-        @obj.mypon.should be_nil
-      end
+        it "should work with numbers, nil, empty strings and spaces" do
+          @obj.mypon = " 54 "
+          @obj.mypon.should == 54
+          @obj.mypon = nil
+          @obj.mypon.should be_nil
+          @obj.mypon = ''
+          @obj.mypon.should be_nil
+          @obj.mypon = '  '
+          @obj.mypon.should be_nil
+        end
 
-      it "should reject non-integers and non-positive integers" do
-        lambda { @obj.mypon = 'X' }.should raise_error(/invalid/)
-        lambda { @obj.mypon = '0' }.should raise_error(/invalid/)
-        lambda { @obj.mypon = -13 }.should raise_error(/invalid/)
-      end
+        it "should reject non-integers and non-positive integers" do
+          lambda { @obj.mypon = 'X' }.should raise_error(/invalid/)
+          lambda { @obj.mypon = '0' }.should raise_error(/invalid/)
+          lambda { @obj.mypon = -13 }.should raise_error(/invalid/)
+        end
 
-      it "should handle multiple names" do
-        @class.attr_integer :ourpon, :theirpon
-        @obj.respond_to?(:ourpon).should be_true
-        @obj.respond_to?(:theirpon=).should be_true
+        it "should handle multiple names" do
+          @class.attr_integer :ourpon, :theirpon
+          @obj.respond_to?(:ourpon).should be_true
+          @obj.respond_to?(:theirpon=).should be_true
+        end
       end
-    end
 
-    context "#attr_date" do
-      before(:each) do
-        @class = Class.new
-        @class.extend ICU::Accessor
-        @class.attr_date :mydate
-        @obj = @class.new
-      end
+      context "#attr_date" do
+        before(:each) do
+          @class = Class.new
+          @class.extend ICU::Util::Accessor
+          @class.attr_date :mydate
+          @obj = @class.new
+        end
 
-      it "should have a getter and setter" do
-        @obj.respond_to?(:mydate).should be_true
-        @obj.respond_to?(:mydate=).should be_true
-      end
+        it "should have a getter and setter" do
+          @obj.respond_to?(:mydate).should be_true
+          @obj.respond_to?(:mydate=).should be_true
+        end
 
-      it "should work as expected" do
-        @obj.mydate = "2009/11/09"
-        @obj.mydate.should == '2009-11-09'
-      end
+        it "should work as expected" do
+          @obj.mydate = "2009/11/09"
+          @obj.mydate.should == '2009-11-09'
+        end
 
-      it "should reject nil and other non-dates" do
-        lambda { @obj.mydate = nil }.should raise_error(/invalid/)
-        lambda { @obj.mydate = 'blah de blah' }.should raise_error(/invalid/)
-        lambda { @obj.mydate = ' ' }.should raise_error(/invalid/)
-        lambda { @obj.mydate = 0 }.should raise_error(/invalid/)
-      end
+        it "should reject nil and other non-dates" do
+          lambda { @obj.mydate = nil }.should raise_error(/invalid/)
+          lambda { @obj.mydate = 'blah de blah' }.should raise_error(/invalid/)
+          lambda { @obj.mydate = ' ' }.should raise_error(/invalid/)
+          lambda { @obj.mydate = 0 }.should raise_error(/invalid/)
+        end
 
-      it "should handle multiple names" do
-        @class.attr_date :ourdate, :theirdate
-        @obj.respond_to?(:ourdate).should be_true
-        @obj.respond_to?(:theirdate=).should be_true
+        it "should handle multiple names" do
+          @class.attr_date :ourdate, :theirdate
+          @obj.respond_to?(:ourdate).should be_true
+          @obj.respond_to?(:theirdate=).should be_true
+        end
       end
-    end
 
-    context "#attr_date_or_nil" do
-      before(:each) do
-        @class = Class.new
-        @class.extend ICU::Accessor
-        @class.attr_date_or_nil :mydate
-        @obj = @class.new
-      end
+      context "#attr_date_or_nil" do
+        before(:each) do
+          @class = Class.new
+          @class.extend ICU::Util::Accessor
+          @class.attr_date_or_nil :mydate
+          @obj = @class.new
+        end
 
-      it "should have a getter and setter" do
-        @obj.respond_to?(:mydate).should be_true
-        @obj.respond_to?(:mydate=).should be_true
-      end
+        it "should have a getter and setter" do
+          @obj.respond_to?(:mydate).should be_true
+          @obj.respond_to?(:mydate=).should be_true
+        end
 
-      it "should work as expected, including with nil" do
-        @obj.mydate = "2009/11/09"
-        @obj.mydate.should == '2009-11-09'
-        @obj.mydate = nil
-        @obj.mydate.should be_nil
-      end
+        it "should work as expected, including with nil" do
+          @obj.mydate = "2009/11/09"
+          @obj.mydate.should == '2009-11-09'
+          @obj.mydate = nil
+          @obj.mydate.should be_nil
+        end
 
-      it "should reject non-dates" do
-        lambda { @obj.mydate = 'blah de blah' }.should raise_error(/invalid/)
-        lambda { @obj.mydate = 0 }.should raise_error(/invalid/)
-      end
+        it "should reject non-dates" do
+          lambda { @obj.mydate = 'blah de blah' }.should raise_error(/invalid/)
+          lambda { @obj.mydate = 0 }.should raise_error(/invalid/)
+        end
 
-      it "should handle multiple names" do
-        @class.attr_date :ourdate, :theirdate
-        @obj.respond_to?(:ourdate).should be_true
-        @obj.respond_to?(:theirdate=).should be_true
+        it "should handle multiple names" do
+          @class.attr_date :ourdate, :theirdate
+          @obj.respond_to?(:ourdate).should be_true
+          @obj.respond_to?(:theirdate=).should be_true
+        end
       end
-    end
 
-    context "#attr_string" do
-      before(:each) do
-        @class = Class.new
-        @class.extend ICU::Accessor
-        @class.attr_string %r%[a-z]+%i, :mystring
-        @obj = @class.new
-      end
+      context "#attr_string" do
+        before(:each) do
+          @class = Class.new
+          @class.extend ICU::Util::Accessor
+          @class.attr_string %r%[a-z]+%i, :mystring
+          @obj = @class.new
+        end
 
-      it "should have a getter and setter" do
-        @obj.respond_to?(:mystring).should be_true
-        @obj.respond_to?(:mystring=).should be_true
-      end
+        it "should have a getter and setter" do
+          @obj.respond_to?(:mystring).should be_true
+          @obj.respond_to?(:mystring=).should be_true
+        end
 
-      it "should work as expected" do
-        @obj.mystring = "  mark   "
-        @obj.mystring.should == 'mark'
-      end
+        it "should work as expected" do
+          @obj.mystring = "  mark   "
+          @obj.mystring.should == 'mark'
+        end
 
-      it "should reject values that don't match" do
-        lambda { @obj.mystring = nil }.should raise_error(/invalid/)
-        lambda { @obj.mystring = ' 123 ' }.should raise_error(/invalid/)
-        lambda { @obj.mystring = ' ' }.should raise_error(/invalid/)
-        lambda { @obj.mystring = 0 }.should raise_error(/invalid/)
-        lambda { @obj.mystring = ' a ' }.should_not raise_error
-        lambda { @obj.mystring = 'ZYX' }.should_not raise_error
-      end
+        it "should reject values that don't match" do
+          lambda { @obj.mystring = nil }.should raise_error(/invalid/)
+          lambda { @obj.mystring = ' 123 ' }.should raise_error(/invalid/)
+          lambda { @obj.mystring = ' ' }.should raise_error(/invalid/)
+          lambda { @obj.mystring = 0 }.should raise_error(/invalid/)
+          lambda { @obj.mystring = ' a ' }.should_not raise_error
+          lambda { @obj.mystring = 'ZYX' }.should_not raise_error
+        end
 
-      it "should handle multiple names" do
-        @class.attr_string %r%^[A-Z]{3}$%, :ourstring, :theirstring
-        @obj.respond_to?(:ourstring=).should be_true
-        @obj.respond_to?(:theirstring).should be_true
+        it "should handle multiple names" do
+          @class.attr_string %r%^[A-Z]{3}$%, :ourstring, :theirstring
+          @obj.respond_to?(:ourstring=).should be_true
+          @obj.respond_to?(:theirstring).should be_true
+        end
       end
-    end
 
-    context "#attr_string_or_nil" do
-      before(:each) do
-        @class = Class.new
-        @class.extend ICU::Accessor
-        @class.attr_string_or_nil %r%^[1-9]\d*$%i, :mystring
-        @obj = @class.new
-      end
+      context "#attr_string_or_nil" do
+        before(:each) do
+          @class = Class.new
+          @class.extend ICU::Util::Accessor
+          @class.attr_string_or_nil %r%^[1-9]\d*$%i, :mystring
+          @obj = @class.new
+        end
 
-      it "should have a getter and setter" do
-        @obj.respond_to?(:mystring).should be_true
-        @obj.respond_to?(:mystring=).should be_true
-      end
+        it "should have a getter and setter" do
+          @obj.respond_to?(:mystring).should be_true
+          @obj.respond_to?(:mystring=).should be_true
+        end
 
-      it "should work as expected" do
-        @obj.mystring = " 12345  "
-        @obj.mystring.should == '12345'
-        @obj.mystring = nil
-        @obj.mystring.should be_nil
-        @obj.mystring = '   '
-        @obj.mystring.should be_nil
-      end
+        it "should work as expected" do
+          @obj.mystring = " 12345  "
+          @obj.mystring.should == '12345'
+          @obj.mystring = nil
+          @obj.mystring.should be_nil
+          @obj.mystring = '   '
+          @obj.mystring.should be_nil
+        end
 
-      it "should reject values that don't match" do
-        lambda { @obj.mystring = ' 0 ' }.should raise_error(/invalid/)
-        lambda { @obj.mystring = 0 }.should raise_error(/invalid/)
-        lambda { @obj.mystring = -1 }.should raise_error(/invalid/)
-        lambda { @obj.mystring = 98 }.should_not raise_error
-      end
+        it "should reject values that don't match" do
+          lambda { @obj.mystring = ' 0 ' }.should raise_error(/invalid/)
+          lambda { @obj.mystring = 0 }.should raise_error(/invalid/)
+          lambda { @obj.mystring = -1 }.should raise_error(/invalid/)
+          lambda { @obj.mystring = 98 }.should_not raise_error
+        end
 
-      it "should handle multiple names" do
-        @class.attr_string %r%^[A-Z][a-z]+%, :ourstring, :theirstring
-        @obj.respond_to?(:ourstring=).should be_true
-        @obj.respond_to?(:theirstring).should be_true
+        it "should handle multiple names" do
+          @class.attr_string %r%^[A-Z][a-z]+%, :ourstring, :theirstring
+          @obj.respond_to?(:ourstring=).should be_true
+          @obj.respond_to?(:theirstring).should be_true
+        end
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: icu_tournament
 version: !ruby/object:Gem::Version
-  version: 1.7.3
+  version: 1.8.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-20 00:00:00.000000000 Z
+date: 2013-10-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dbf
@@ -174,7 +174,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 4531625935937498551
+      hash: 906985998380119772
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -183,7 +183,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 4531625935937498551
+      hash: 906985998380119772
 requirements: []
 rubyforge_project: icu_tournament
 rubygems_version: 1.8.23