icu_utils 1.1.1 → 1.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f97cfbd598b1e453a7e2dcf3de583f60ba462d75
+  data.tar.gz: 525cbf547ee580ada1da81cbf4da119361a0c353
+SHA512:
+  metadata.gz: cfa42575c3b40cec0f6aa7f531f6db3192009dd44599ab600ef800ca196d65c6b147b1c3825e4daf9799276f699464ec945ba0afdbfc463b6fd5919849fb13ec
+  data.tar.gz: eb0da907423c6d21a4b44c2ca4a8be8de670b4758b06947709dbaa8aadd55fb0a9b272a118376807524ab2c34f58e2a9e442c6f3e00ddea0befbd795f9989c93

data/.rspec

@@ -1,2 +1,2 @@
 --colour
---format nested
+--format doc

data/.ruby-version

@@ -0,0 +1 @@
+2.0.0-p353

data/Gemfile.lock

@@ -1,30 +1,34 @@
 PATH
   remote: .
   specs:
-    icu_utils (1.1.1)
+    icu_utils (1.2.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
     diff-lcs (1.2.5)
     json (1.8.1)
-    rake (10.1.0)
-    rdoc (4.0.1)
+    rake (10.3.2)
+    rdoc (4.1.1)
       json (~> 1.4)
-    rspec (2.14.1)
-      rspec-core (~> 2.14.0)
-      rspec-expectations (~> 2.14.0)
-      rspec-mocks (~> 2.14.0)
-    rspec-core (2.14.7)
-    rspec-expectations (2.14.4)
-      diff-lcs (>= 1.1.3, < 2.0)
-    rspec-mocks (2.14.4)
+    rspec (3.0.0)
+      rspec-core (~> 3.0.0)
+      rspec-expectations (~> 3.0.0)
+      rspec-mocks (~> 3.0.0)
+    rspec-core (3.0.4)
+      rspec-support (~> 3.0.0)
+    rspec-expectations (3.0.4)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.0.0)
+    rspec-mocks (3.0.4)
+      rspec-support (~> 3.0.0)
+    rspec-support (3.0.4)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  bundler (~> 1.3)
+  bundler
   icu_utils!
   rake
   rdoc

data/README.md

@@ -2,7 +2,7 @@
 
 A place for utilities shared across the various ICU apps and gems.
 
-So far just includes a class to handle FIDE federations.
+Includes a class to handle FIDE federations and one to do date validation.
 
 ## Installation
 

data/icu_utils.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |s|
   s.test_files       = s.files.grep(%r{^(spec)/})
   s.require_paths    = ["lib"]
 
-  s.add_development_dependency "bundler", "~> 1.3"
+  s.add_development_dependency "bundler"
   s.add_development_dependency "rake"
   s.add_development_dependency "rspec"
   s.add_development_dependency "rdoc"

data/lib/icu_utils/date.rb

@@ -0,0 +1,72 @@
+module ICU
+  # Reproduce some of the functionality of validates_timeliness, a gem no longer maintained.
+  class Date
+    attr_reader :date, :reasons
+
+    def initialize(date, constraints={})
+      @reasons = []
+      if @date = to_date(date)
+        @constraints = constraints.each_with_object({}) do |(k,v), h|
+          if %i[after on_or_after before on_or_before].include?(k)
+            unless h[k] = to_date(v)
+              raise ArgumentError.new("invalid date specified for #{k} constraint")
+            end
+          else
+            raise ArgumentError.new("invalid date constraint #{k}")
+          end
+        end
+      else
+        @reasons.push "errors.messages.invalid_date"
+      end
+    end
+
+    def valid?
+      valid = true
+      if @date
+        if valid && @constraints[:after] && @date <= @constraints[:after]
+          valid = false
+          @reasons.push "errors.messages.after"
+          @reasons.push restriction: @constraints[:after].to_s
+        end
+        if valid && @constraints[:before] && @date >= @constraints[:before]
+          valid = false
+          @reasons.push "errors.messages.before"
+          @reasons.push restriction: @constraints[:before].to_s
+        end
+        if valid && @constraints[:on_or_after] && @date < @constraints[:on_or_after]
+          valid = false
+          @reasons.push "errors.messages.on_or_after"
+          @reasons.push restriction: @constraints[:on_or_after].to_s
+        end
+        if valid && @constraints[:on_or_before] && @date > @constraints[:on_or_before]
+          valid = false
+          @reasons.push "errors.messages.on_or_before"
+          @reasons.push restriction: @constraints[:on_or_before].to_s
+        end
+      else
+        valid = false
+      end
+      valid
+    end
+
+    # after: must be after %{restriction}
+    # before: must be before %{restriction}
+    # invalid: invalid
+    # invalid_date: invalid date
+    # on_or_after: must be on or after %{restriction}
+    # on_or_before: must be on or before %{restriction}
+
+    private
+
+    def to_date(thing)
+      if thing.is_a?(Date)
+        thing.dup
+      else
+        thing = ::Date.parse(thing.to_s)
+      end
+      thing
+    rescue
+      nil
+    end
+  end
+end

data/lib/icu_utils/version.rb

@@ -1,3 +1,3 @@
 module IcuUtils
-  VERSION = "1.1.1"
+  VERSION = "1.2.0"
 end

data/lib/icu_utils.rb

@@ -1,2 +1,3 @@
 require 'icu_utils/version'
 require 'icu_utils/federation'
+require 'icu_utils/date'

data/spec/date_spec.rb

@@ -0,0 +1,174 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+module ICU
+  describe Date do
+    context "no constraints" do
+      it "today" do
+        today = ICU::Date.new(::Date.today)
+        expect(today).to be_valid
+        expect(today.date).to eq ::Date.today
+        expect(today.reasons).to be_empty
+      end
+
+      it "now" do
+        now = ICU::Date.new(Time.now)
+        expect(now).to be_valid
+        expect(now.date).to eq ::Date.today
+        expect(now.reasons).to be_empty
+      end
+
+      it "human" do
+        now = ICU::Date.new("9th November 1955")
+        expect(now).to be_valid
+        expect(now.date).to eq ::Date.new(1955, 11, 9)
+        expect(now.reasons).to be_empty
+      end
+
+      it "abbreviated" do
+        now = ICU::Date.new("June 16 1986")
+        expect(now).to be_valid
+        expect(now.date).to eq ::Date.new(1986, 6, 16)
+        expect(now.reasons).to be_empty
+      end
+
+      it "invalid" do
+        invalid = ICU::Date.new("rubbish")
+        expect(invalid).to_not be_valid
+        expect(invalid.reasons).to_not be_empty
+        expect(invalid.reasons.size).to eq 1
+        expect(invalid.reasons.first).to eq "errors.messages.invalid_date"
+      end
+
+      it "impossible" do
+        invalid = ICU::Date.new("2014-02-30")
+        expect(invalid).to_not be_valid
+        expect(invalid.reasons).to_not be_empty
+        expect(invalid.reasons.size).to eq 1
+        expect(invalid.reasons.first).to eq "errors.messages.invalid_date"
+      end
+    end
+
+    context "after" do
+      it "today/yesterday" do
+        d = ICU::Date.new(::Date.today, after: ::Date.today - 1)
+        expect(d).to be_valid
+        expect(d.date).to eq ::Date.today
+        expect(d.reasons).to be_empty
+      end
+
+      it "yesterday/today" do
+        d = ICU::Date.new(::Date.today - 1, after: ::Date.today)
+        expect(d).to_not be_valid
+        expect(d.date).to eq ::Date.today - 1
+        expect(d.reasons[0]).to eq "errors.messages.after"
+        expect(d.reasons[1]).to eq restriction: ::Date.today.to_s
+      end
+
+      it "today/today" do
+        d = ICU::Date.new(::Date.today, after: ::Date.today)
+        expect(d).to_not be_valid
+        expect(d.date).to eq ::Date.today
+        expect(d.reasons[0]).to eq "errors.messages.after"
+        expect(d.reasons[1]).to eq restriction: ::Date.today.to_s
+      end
+
+      it "invalid" do
+        expect{ICU::Date.new(::Date.today, after: "rubbish")}.to raise_error(/invalid/)
+      end
+    end
+
+    context "on or after" do
+      it "today/yesterday" do
+        d = ICU::Date.new(::Date.today, on_or_after: ::Date.today - 1)
+        expect(d).to be_valid
+        expect(d.date).to eq ::Date.today
+        expect(d.reasons).to be_empty
+      end
+
+      it "yesterday/today" do
+        d = ICU::Date.new(::Date.today - 1, on_or_after: ::Date.today)
+        expect(d).to_not be_valid
+        expect(d.date).to eq ::Date.today - 1
+        expect(d.reasons[0]).to eq "errors.messages.on_or_after"
+        expect(d.reasons[1]).to eq restriction: ::Date.today.to_s
+      end
+
+      it "today/today" do
+        d = ICU::Date.new(::Date.today, on_or_after: ::Date.today)
+        expect(d).to be_valid
+        expect(d.date).to eq ::Date.today
+        expect(d.reasons).to be_empty
+      end
+
+      it "impossible" do
+        expect{ICU::Date.new(::Date.today, on_or_after: ::Date.new(1955, 2, 29))}.to raise_error(/invalid/)
+      end
+    end
+
+    context "before" do
+      it "yesterday/today" do
+        d = ICU::Date.new(::Date.today - 1, before: ::Date.today)
+        expect(d).to be_valid
+        expect(d.date).to eq ::Date.today - 1
+        expect(d.reasons).to be_empty
+      end
+
+      it "today/yesterday" do
+        d = ICU::Date.new(::Date.today, before: ::Date.today - 1)
+        expect(d).to_not be_valid
+        expect(d.date).to eq ::Date.today
+        expect(d.reasons[0]).to eq "errors.messages.before"
+        expect(d.reasons[1]).to eq restriction: (::Date.today - 1).to_s
+      end
+
+      it "today/today" do
+        d = ICU::Date.new(::Date.today, before: ::Date.today.to_s)
+        expect(d).to_not be_valid
+        expect(d.date).to eq ::Date.today
+        expect(d.reasons[0]).to eq "errors.messages.before"
+        expect(d.reasons[1]).to eq restriction: ::Date.today.to_s
+      end
+
+      it "invalid" do
+        expect{ICU::Date.new(::Date.today, before: "")}.to raise_error(/invalid/)
+      end
+    end
+
+    context "on or before" do
+      it "yesterday/today" do
+        d = ICU::Date.new(::Date.today - 1, on_or_before: ::Date.today.to_s)
+        expect(d).to be_valid
+        expect(d.date).to eq ::Date.today - 1
+        expect(d.reasons).to be_empty
+      end
+
+      it "today/yesterday" do
+        d = ICU::Date.new(::Date.today, on_or_before: ::Date.today - 1)
+        expect(d).to_not be_valid
+        expect(d.date).to eq ::Date.today
+        expect(d.reasons[0]).to eq "errors.messages.on_or_before"
+        expect(d.reasons[1]).to eq restriction: (::Date.today - 1).to_s
+      end
+
+      it "today/today" do
+        d = ICU::Date.new(::Date.today, on_or_before: ::Date.today)
+        expect(d).to be_valid
+        expect(d.date).to eq ::Date.today
+        expect(d.reasons).to be_empty
+      end
+
+      it "impossible" do
+        expect{ICU::Date.new(::Date.today, on_or_before: "2014-06-31")}.to raise_error(/invalid/)
+      end
+    end
+  end
+
+  context "multiple constraints" do
+    it "today/today" do
+      d = ICU::Date.new(::Date.today, on_or_after: ::Date.today.to_s, on_or_before: ::Date.today)
+      expect(d).to be_valid
+      expect(d.date).to eq ::Date.today
+      expect(d.reasons).to be_empty
+    end
+  end
+end

data/spec/federation_spec.rb

@@ -7,185 +7,185 @@ module ICU
     context "#find using codes" do
       it "should find a federation given a valid code" do
         fed = Federation.find('IRL')
-        fed.code.should == 'IRL'
-        fed.name.should == 'Ireland'
+        expect(fed.code).to eq('IRL')
+        expect(fed.name).to eq('Ireland')
       end
 
       it "should find a federation from code case insensitively" do
         fed = Federation.find('rUs')
-        fed.code.should == 'RUS'
-        fed.name.should == 'Russia'
+        expect(fed.code).to eq('RUS')
+        expect(fed.name).to eq('Russia')
       end
 
       it "should find a federation despite irrelevant whitespace" do
         fed = Federation.find('  mex    ')
-        fed.code.should == 'MEX'
-        fed.name.should == 'Mexico'
+        expect(fed.code).to eq('MEX')
+        expect(fed.name).to eq('Mexico')
       end
 
       it "should return nil for an invalid code" do
-        Federation.find('XYZ').should be_nil
+        expect(Federation.find('XYZ')).to be_nil
       end
     end
 
     context "#find using names" do
       it "should find a federation given a valid name" do
         fed = Federation.find('England')
-        fed.code.should == 'ENG'
-        fed.name.should == 'England'
+        expect(fed.code).to eq('ENG')
+        expect(fed.name).to eq('England')
       end
 
       it "should find a federation from name case insensitively" do
         fed = Federation.find('franCE')
-        fed.code.should == 'FRA'
-        fed.name.should == 'France'
+        expect(fed.code).to eq('FRA')
+        expect(fed.name).to eq('France')
       end
 
       it "should not be fooled by irrelevant whitespace" do
         fed = Federation.find(' united  states  of  america ')
-        fed.code.should == 'USA'
-        fed.name.should == 'United States of America'
+        expect(fed.code).to eq('USA')
+        expect(fed.name).to eq('United States of America')
       end
 
       it "should return nil for an invalid name" do
-        Federation.find('Mordor').should be_nil
+        expect(Federation.find('Mordor')).to be_nil
       end
     end
 
     context "#find using parts of names" do
       it "should find a federation given a substring which is unique and at least 4 characters" do
         fed = Federation.find('bosni')
-        fed.code.should == 'BIH'
-        fed.name.should == 'Bosnia and Herzegovina'
+        expect(fed.code).to eq('BIH')
+        expect(fed.name).to eq('Bosnia and Herzegovina')
       end
 
       it "should not be fooled by irrelevant whitespace" do
         fed = Federation.find('  arab    EMIRATES   ')
-        fed.code.should == 'UAE'
-        fed.name.should == 'United Arab Emirates'
+        expect(fed.code).to eq('UAE')
+        expect(fed.name).to eq('United Arab Emirates')
       end
 
       it "should not find a federation if the substring matches more than one" do
-        Federation.find('land').should be_nil
+        expect(Federation.find('land')).to be_nil
       end
 
       it "should return nil for any string smaller in length than 3" do
-        Federation.find('ze').should be_nil
+        expect(Federation.find('ze')).to be_nil
       end
     end
 
     context "#find federations with alternative names" do
       it "should find Macedonia multiple ways" do
-        Federation.find('MKD').name.should == 'Macedonia'
-        Federation.find('FYROM').name.should == 'Macedonia'
-        Federation.find('macedoni').name.should == 'Macedonia'
-        Federation.find('Macedonia').name.should == 'Macedonia'
-        Federation.find('former YUG Rep').name.should == 'Macedonia'
-        Federation.find('Republic of Macedonia').name.should == 'Macedonia'
-        Federation.find('former yugoslav republic').name.should == 'Macedonia'
+        expect(Federation.find('MKD').name).to eq('Macedonia')
+        expect(Federation.find('FYROM').name).to eq('Macedonia')
+        expect(Federation.find('macedoni').name).to eq('Macedonia')
+        expect(Federation.find('Macedonia').name).to eq('Macedonia')
+        expect(Federation.find('former YUG Rep').name).to eq('Macedonia')
+        expect(Federation.find('Republic of Macedonia').name).to eq('Macedonia')
+        expect(Federation.find('former yugoslav republic').name).to eq('Macedonia')
       end
     end
 
     context "#find from common code errors" do
       it "should find IRL from ICU" do
-        Federation.find('ICU').code.should == 'IRL'
-        Federation.find('SPA').code.should == 'ESP'
-        Federation.find('WAL').code.should == 'WLS'
+        expect(Federation.find('ICU').code).to eq('IRL')
+        expect(Federation.find('SPA').code).to eq('ESP')
+        expect(Federation.find('WAL').code).to eq('WLS')
       end
     end
 
     context "#find with alternative inputs" do
       it "should behave robustly with completely invalid inputs" do
-        Federation.find().should be_nil
-        Federation.find(nil).should be_nil
-        Federation.find('').should be_nil
-        Federation.find(1).should be_nil
+        expect(Federation.find()).to be_nil
+        expect(Federation.find(nil)).to be_nil
+        expect(Federation.find('')).to be_nil
+        expect(Federation.find(1)).to be_nil
       end
     end
 
     context "#new is private" do
       it "#new cannot be called directly" do
-        lambda { Federation.new('IRL', 'Ireland') }.should raise_error(/private method/)
+        expect { Federation.new('IRL', 'Ireland') }.to raise_error(/private method/)
       end
     end
 
     context "documentation examples" do
       it "should all be correct for valid input" do
-        Federation.find('IRL').name.should == 'Ireland'
-        Federation.find('IRL').code.should == 'IRL'
-        Federation.find('rUs').code.should == 'RUS'
-        Federation.find('ongoli').name.should == 'Mongolia'
-        Federation.find('  united   states   ').code.should == 'USA'
+        expect(Federation.find('IRL').name).to eq('Ireland')
+        expect(Federation.find('IRL').code).to eq('IRL')
+        expect(Federation.find('rUs').code).to eq('RUS')
+        expect(Federation.find('ongoli').name).to eq('Mongolia')
+        expect(Federation.find('  united   states   ').code).to eq('USA')
       end
 
       it "should return nil for invalid input" do
-        Federation.find('ZYX').should be_nil
-        Federation.find('land').should be_nil
+        expect(Federation.find('ZYX')).to be_nil
+        expect(Federation.find('land')).to be_nil
       end
     end
 
     context "#menu" do
       it "should return array of name-code pairs in order of name by default" do
         menu = Federation.menu
-        menu.should have(total).items
+        expect(menu.size).to eq(total)
         names = menu.map{|m| m.first}.join(',')
         codes = menu.map{|m| m.last}.join(',')
-        names.index('Afghanistan').should == 0
-        names.index('Iraq,Ireland,Israel').should_not be_nil
-        codes.index('AFG').should == 0
-        codes.index('IRQ,IRL,ISR').should_not be_nil
+        expect(names.index('Afghanistan')).to eq(0)
+        expect(names.index('Iraq,Ireland,Israel')).not_to be_nil
+        expect(codes.index('AFG')).to eq(0)
+        expect(codes.index('IRQ,IRL,ISR')).not_to be_nil
       end
 
       it "should be configuarble to order the list by codes" do
         menu = Federation.menu(:order => "code")
-        menu.should have(total).items
+        expect(menu.size).to eq(total)
         names = menu.map{|m| m.first}.join(',')
         codes = menu.map{|m| m.last}.join(',')
-        names.index('Afghanistan').should == 0
-        names.index('Ireland,Iraq,Iceland').should_not be_nil
-        codes.index('AFG').should == 0
-        codes.index('IRL,IRQ,ISL').should_not be_nil
+        expect(names.index('Afghanistan')).to eq(0)
+        expect(names.index('Ireland,Iraq,Iceland')).not_to be_nil
+        expect(codes.index('AFG')).to eq(0)
+        expect(codes.index('IRL,IRQ,ISL')).not_to be_nil
       end
 
       it "should be configuarble to have a selected country at the top" do
         menu = Federation.menu(:top => 'IRL')
-        menu.should have(total).items
+        expect(menu.size).to eq(total)
         names = menu.map{|m| m.first}.join(',')
         codes = menu.map{|m| m.last}.join(',')
-        names.index('Ireland,Afghanistan').should == 0
-        names.index('Iraq,Israel').should_not be_nil
-        codes.index('IRL,AFG').should == 0
-        codes.index('IRQ,ISR').should_not be_nil
+        expect(names.index('Ireland,Afghanistan')).to eq(0)
+        expect(names.index('Iraq,Israel')).not_to be_nil
+        expect(codes.index('IRL,AFG')).to eq(0)
+        expect(codes.index('IRQ,ISR')).not_to be_nil
       end
 
       it "should be configuarble to have 'None' entry at the top" do
         menu = Federation.menu(:none => 'None')
-        menu.should have(total + 1).items
+        expect(menu.size).to eq(total + 1)
         names = menu.map{|m| m.first}.join(',')
         codes = menu.map{|m| m.last}.join(',')
-        names.index('None,Afghanistan').should == 0
-        codes.index(',AFG').should == 0
+        expect(names.index('None,Afghanistan')).to eq(0)
+        expect(codes.index(',AFG')).to eq(0)
       end
 
       it "should be able to handle multiple configuarations" do
         menu = Federation.menu(:top => 'IRL', :order => 'code', :none => 'None')
-        menu.should have(total + 1).items
+        expect(menu.size).to eq(total + 1)
         names = menu.map{|m| m.first}.join(',')
         codes = menu.map{|m| m.last}.join(',')
-        names.index('None,Ireland,Afghanistan').should == 0
-        names.index('Iraq,Iceland').should_not be_nil
-        codes.index(',IRL,AFG').should == 0
-        codes.index('IRQ,ISL').should_not be_nil
+        expect(names.index('None,Ireland,Afghanistan')).to eq(0)
+        expect(names.index('Iraq,Iceland')).not_to be_nil
+        expect(codes.index(',IRL,AFG')).to eq(0)
+        expect(codes.index('IRQ,ISL')).not_to be_nil
       end
     end
 
     context "#codes" do
       it "should return array of codes ordered alphabetically" do
         codes = Federation.codes
-        codes.should have(total).items
+        expect(codes.size).to eq(total)
         all = codes.join(',')
-        all.index('AFG').should == 0
-        all.index('INA,IND,IRI,IRL,IRQ,ISL,ISR,ISV,ITA,IVB').should_not be_nil
+        expect(all.index('AFG')).to eq(0)
+        expect(all.index('INA,IND,IRI,IRL,IRQ,ISL,ISR,ISV,ITA,IVB')).not_to be_nil
       end
     end
 

metadata

@@ -1,78 +1,69 @@
 --- !ruby/object:Gem::Specification
 name: icu_utils
 version: !ruby/object:Gem::Version
-  version: 1.1.1
-  prerelease: 
+  version: 1.2.0
 platform: ruby
 authors:
 - Mark Orr
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-15 00:00:00.000000000 Z
+date: 2014-08-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - '>='
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - '>='
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rdoc
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 description: A place for shared utilities for sharing between the various ICU apps
@@ -87,6 +78,7 @@ extra_rdoc_files:
 files:
 - .gitignore
 - .rspec
+- .ruby-version
 - Gemfile
 - Gemfile.lock
 - Icon.png
@@ -99,41 +91,37 @@ files:
 - bin/rspec
 - icu_utils.gemspec
 - lib/icu_utils.rb
+- lib/icu_utils/date.rb
 - lib/icu_utils/federation.rb
 - lib/icu_utils/version.rb
+- spec/date_spec.rb
 - spec/federation_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/sanichi/icu_utils
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -1389679885683086703
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -1389679885683086703
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.1.11
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Shared ICU utilities
 test_files:
+- spec/date_spec.rb
 - spec/federation_spec.rb
 - spec/spec_helper.rb