edtf 0.0.9 → 1.0.0

data/README.md

@@ -1,8 +1,8 @@
 EDTF-Ruby
 =========
 
-Ruby implementation of the [Extended Date/Time Format
-Specification](http://www.loc.gov/standards/datetime/spec.html).
+EDTF-Ruby comprises a parser and an API implementation of the [Extended
+Date/Time Format standard](http://www.loc.gov/standards/datetime/spec.html).
 
 
 Compatibility
@@ -11,8 +11,6 @@ Compatibility
 EDTF-Ruby parser implements all levels and features of the EDTF specification
 (version September 16, 2011). With the following known caveats:
 
-* Uncertain/approximate seasons will be parsed, but the Season class does
-  not implement attributes.
 * In the latest revision of the EDTF specification alternative versions of
   partial uncertain/approximate strings were introduced (with or without nested
   parentheses); EDTF-Ruby currently uses the version that tries to reduce
@@ -23,31 +21,115 @@ EDTF-Ruby parser implements all levels and features of the EDTF specification
 
 EDTF-Ruby has been confirmed to work on the following Ruby implementations:
 1.9.3, 1.9.2, 1.8.7, Rubinius, and JRuby. Active Support's date extensions
-are currently listed as a dependency, because of a number of many functional
-overlaps.
+are currently listed as a dependency, because of many functional overlaps.
 
 
 Quickstart
 ----------
 
 EDTF Ruby is implemented as an extension to the regular Ruby date/time classes.
-You can access parse EDTF strings either using `Date.edtf` or `EDTF.parse`
+You can parse EDTF strings either using `Date.edtf` or `EDTF.parse`
 (both methods come with an alternative bang! version, that will raise an error
 if the string cannot be parsed instead of silently returning nil); if
 given a valid EDTF string the return value will either be an (extended) `Date`,
-`EDTF::Interval`, `EDTF::Set`, or `Range` (for masked precision strings)
-instance. Given a Date, you can print the corresponding EDTF string using the
-`#edtf` method.
+`EDTF::Interval`, `EDTF::Set`, `EDTF::Epoch` or `EDTF::Season` instance.
+
+Given any of these instances, you can print the corresponding EDTF string
+using the `#edtf` method.
+
+=== Dates
+
+Most of the EDTF features deal with dates; EDTF-Ruby implements these by
+extending Active Support's version of the regular Ruby Date class. The library
+intends to be transparent to Ruby's regular API, i.e., every Date instance
+should act as you would normally expect but provides additional functionality.
+
+Most, notably, EDTF dates come in day, month, or year precision. This is a
+subtle difference that determines how many other methods work. For instance:
+
+    > Date.today.precision
+    => :day
+    > Date.today
+    => Thu, 10 Nov 2011
+    > Date.today.succ
+    => Fri, 11 Nov 2011
+    > Date.today.month_precision!.succ
+    => Sat, 10 Dec 2011
+    
+As you can see, dates have day precision by default; after setting the date's
+precision to month, however, the natural successor is not the next day, but
+a day a month from now. Always keep precision in mind when comparing dates,
+too:
+
+    > Date.new(1666).year_precision! == Date.new(1966)
+    => false
+    
+The year 1666 is not equal to the January 1st, 1966. You can set a date's
+precision directly, or else use the dedicated bang! methods:
+
+    > d = Date.new(1993)
+    > d.day_precision?   # -> true
+    > d.edtf
+    => "1993-01-01"
+    > d.month_precision!
+    > d.edtf
+    => "1993-01"
+    > d.year_precision!
+    > d.edtf
+    => "1993"
+    > d.day_precision?    # -> false
+    > d.year_precision?   # -> true
+
+In the examples above, you also see that the `#edtf` method will print a
+different string depending on the date's current precision.
+
+The second important extension is that dates can be uncertain and or
+approximate. The distinction between the two may seem somewhat contrived,
+but we have come to understand it as follows:
+
+Assume you take a history exam and have to answer one of those dreaded
+questions that require you to say exactly in what year a certain event
+happened; you studied hard, but all of a sudden you are *uncertain*: was
+that the year 1683 or was it 1638? This is what uncertainty is in the
+parlance of EDTF: in fact, you would write it just like that "1638?".
+
+Approximate dates are similar but slightly different. Lets say you want
+to tell a story about something that happened to you one winter; you
+don't recall the exact date, but you know it must have been sometime
+between Christmas and New Year's. Come to think of it, you don't
+remember the year either, but you must have been around ten years old.
+Using EDTF, you could write something like "1993~-12-(27)~": this
+indicates that both the year and the day are approximations: perhaps
+the day is not the 27th but it is somewhere close.
+
+This is the main difference between uncertain and approximate in
+EDTF (in our opinion at least): approximate always means close to the
+actual number, whilst uncertain could be something completely different
+(just as there is a large temporal distance between 1638 and 1683).
+
+Here are a few examples of how you can access the uncertain/approximate
+state of dates in Ruby:
 
-    $ [sudo] gem install edtf
-    $ irb
-    > require 'edtf'
     > d = Date.edtf('1984?')
     > d.uncertain?
     => true
+    > d.uncertain? :year
+    => true
+    > d.uncertain? :day
+    => false
     > d.approximate!
     > d.edtf
     => "1984?~"
+    > d.month_precision!
+    > d.approximate! :month
+    > d.edtf
+    => "1984?-01~"
+
+As you can see above, you can use the bang! methods to set individual date
+parts.
+
+In addition, EDTF supports *unspecified* date parts:
+
     > d = Date.edtf('1999-03-uu')
     > d.unspecified?
     => true
@@ -58,49 +140,169 @@ instance. Given a Date, you can print the corresponding EDTF string using the
     > d.unspecified! :month
     > d.edtf
     => "1999-uu-uu"
-    > Date.edtf!('2003-24').winter?
-    => true
-    > Date.edtf!('196x')
-    => #<Date: 1960-01-01>...#<Date: 1970-01-01>
+
+All three, uncertain, approximate, and unspecified attributes do not factor
+into date calculations (like comparisons or successors etc.).
+
+EDTF long or scientific years are mapped to normal date instances.
+
     > Date.edtf('y-17e7').year
     => -170000000
+
+When printing date strings, EDTF-Ruby will try to avoid nested parentheses:
+
+    > Date.edtf("(1999-(02)~-23)?").edtf
+    => "1999?-(02)?~-23?"
+
+
+=== Intervals
+
+If you parse an EDTF interval, the EDTF-Ruby parser will return an instance
+of `EDTF::Interval`; intervals mimic regular Ruby ranges, but offer additional
+functionality.
+
     > d = Date.edtf('1984-06?/2004-08?')
     > d.from.uncertain?
     => true
     > d.include?(Date.new(1987,04,13))
-    => false # the day is not included because interval has month precision    
+    => false
+    
+The day is not included because interval has month precision. However:
+
     > d.cover?(Date.new(1987,04,13))
-    => true # but the day is still covered by the interval
+    => true
+    
+The day is still covered by the interval. In general, optimized in the
+same way that Ruby optimizes numeric ranges. Additionally, precision
+plays into the way intervals are enumerated:
+
     > d.length
-    => 243 # months between 1984-06-01 and 2004-08-31
+    => 243
+    
+There are 243 months between 1984-06-01 and 2004-08-31.
+
     > d.step(36).map(&:year)
-    => [1984, 1987, 1990, 1993, 1996, 1999, 2002] # 36-month steps
+    => [1984, 1987, 1990, 1993, 1996, 1999, 2002]
+    
+Here we iterate through the interval in 36-month steps and map each date to
+the year.
+
     > Date.edtf('1582-10-01/1582-10-31').length
-    => 21 # number of days in October 1582 (Gregorian calendar)
+    => 21
+    
+This interval has day precision, so 21 is the number of days in October 1582,
+which was cut short because of the Gregorian calendar reform.
+
+Intervals can be open or have unknown start or end dates.
+
     > Date.edtf('2004/open').open?
     => true
     > Date.edtf('2004/open').cover?(Date.today)
-    => true # an open ended interval covers today
-    > Date.edtf("(1999-(02)~-23)?").edtf
-    => "1999?-(02)?~-23?" # when printing, EDTF-Ruby reduces nested parentheses
+    => true
+    
+=== Sets
+
+EDTF supports two kind of sets: choice lists (meaning one date out of a list),
+or inclusive lists. In EDTF-Ruby, these are covered by the class `EDTF::Set`
+and the `choice` attribute.
+
     > s = Date.edtf('{1667,1668, 1670..1672}')
+    > s.choice?
+    => false
+    > s.choice!
+    > s.edtf
+    => "[1667, 1668, 1670..1672]"
+    
+As you can see above, EDTF-Ruby remembers which parts of the set were
+specified as a range; ranges are however enumerated for membership tests:
+
     > s.include?(Date.edtf('1669'))
     => false
     > s.include?(Date.edtf('1671'))
-    => true # the range is enumerated for membership tests
+    => true
+    
+Even though we're still aware that the year 1671 was is not directly an
+element of the set:
+
     > s.length
-    => 3 # but we're still aware that there were only three elements
+    => 3
+    
+When in doubt, you can always map the set to an array. This will also
+enumerate all ranges:
+
     > s.map(&:year)
     => [1667, 1668, 1670, 1671, 1672] # when enumerated there are 5 elements
+    
+EDTF sets also feature an `#earlier?` and `#later?` attribute:
+
     > s.earlier?
-    => false # the original list was not vague
-    > s.earlier! # but we can make it so
+    => false
+    > s.earlier!
+    > s.edtf
+    => "[..1667, 1668, 1670..1672]"
+
+
+=== Decades and Centuries
+
+The EDTF specification supports so called masked precision strings to define
+decades or centuries. EDTF-Ruby maps these to dedicated intervals which
+always cover 10 or 100 years, respectively.
+
+    > d = Date.edtf!('196x')
+    => 196x
+    > d.class
+    => EDTF::Decade
+    > d.class
+    => EDTF::Decade
+    > d.min
+    => Fri, 01 Jan 1960
+    > d.max
+    => Wed, 31 Dec 1969
+    > d.map(&:year)
+    => [1960, 1961, 1962, 1963, 1964, 1965, 1966, 1967, 1968, 1969]
+
+=== Seasons
+
+Finally, EDTF covers seasons. Again, EDTF-Ruby provides a dedicated class
+for this. Note that EDTF does not make any assumption about the specifics
+(which months etc.) of the season and you don't have to either; however
+EDTF-Ruby defines method aliases which allow you to access the seasons
+by the names spring, summer, autumn (or fall), and winter, respectively.
+You can also use the more neutral taxonomy of first, second, third,
+fourth.
+
+    > w = Date.edtf!('2003-24')
+    > w.winter?
+    => true
+    > s = w.succ
+    > s.spring?
+    => true
+    > s.year
+    => 2004
+    > s.min
+    => Mon, 01 Mar 2004
+    > s.max
+    => Mon, 31 May 2004
+    > s.to_a.length
+    => 92
+    005:0> w.to_a.length
+    => 91
+
+As you can see, spring 2004 lasted one day longer than winter 2003 (note
+that spring and winter here do not relate to the astronomical seasons
+but strictly to three month periods).
+
+Of course you can print seasons to EDTF strings, too. Finally, seasons can
+be uncertain/approximate.
+
     > s.edtf
-    => "{..1667, 1668, 1670..1672}"
+    => "2004-21"
+    > s.approximate!.edtf
+    => "2004-21"
 
 
-For additional features take a look at the documentation or the extensive
-list of rspec examples.
+For additional features, please take a look at the documentation or the
+extensive list of rspec examples.
 
 
 Contributing

data/edtf.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |s|
   s.platform    = Gem::Platform::RUBY
   s.authors     = ['Sylvester Keil']
   s.email       = ['http://sylvester.keil.or.at']
-  s.homepage    = 'http://inukshuk.github.com/edtf-ruby'
+  s.homepage    = 'http://github.com/inukshuk/edtf-ruby'
   s.summary     = 'Extended Date/Time Format for Ruby.'
   s.description = 'A Ruby implementation of the Extended Date/Time Format (EDTF).'
   s.license     = 'FreeBSD'

data/features/parser/precision.feature

@@ -10,5 +10,5 @@ Feature: Parse masked precision strings
   @level2 @2041
   Scenarios: decades and centuries
     | string | start | end  |
-    | 196x   | 1960  | 1970 |
-    | 19xx   | 1900  | 2000 |
+    | 196x   | 1960  | 1969 |
+    | 19xx   | 1900  | 1999 |

data/features/step_definitions/edtf_steps.rb

@@ -73,7 +73,7 @@ Then /^the interval should include the date "([^"]*)"$/ do |date|
 end
 
 Then /^the interval should cover the date "([^"]*)"$/ do |date|
-  @date.should cover(Date.parse(date))
+  @date.should be_cover(Date.parse(date))
 end
 
 

data/lib/edtf/date.rb

@@ -223,17 +223,15 @@ class Date
 
 	alias to_edtf edtf
 	
-	# Returns the Date of the next day, month, or year depending on the
+	# Returns an array of the next n days, months, or years depending on the
 	# current Date/Time's precision.
   def next(n = 1)
-    if n > 1
-      1.upto(n).map { |by| advance(PRECISIONS[precision] => by) }
-    else
-      advance(PRECISIONS[precision] => 1)
-    end
+  	1.upto(n).map { |by| advance(PRECISIONS[precision] => by) }
   end
 
-  alias succ next
+	def succ
+		advance(PRECISIONS[precision] => 1)
+	end
 
 	# Returns the Date of the previous day, month, or year depending on the
 	# current Date/Time's precision.
@@ -281,7 +279,7 @@ class Date
   end
   
   def update_precision_filter
-    case @precision
+    @precision_filter = case precision
     when :year
       [:year]
     when :month

data/lib/edtf/epoch.rb

@@ -1,57 +1,106 @@
 module EDTF
-  class Epoch
-    
-    extend Forwardable
-    
-    include Enumerable
-    include Comparable
-    
-    attr_accessor :year
-    
-    alias get year
-    alias set year=
 
-    private_class_method :new
-    
-    def initialize(year = 0)
-    end
-        
-    def <=>(other)
-    end
-    
-    
-    def to_date
-      Date.new(year)
-    end
-    
-  end
-  
-  class Century < Epoch
+	class Epoch 
+		extend Forwardable
 
-    def_delegator :to_range, :each
-    
-    def to_range
-      d = to_date
-      d .. d.years_since(100).end_of_year
-    end
-    
-    def to_edtf
-      '%02dxx' % (year / 100)
-    end
-    
-  end
-  
-  class Decade < Epoch
+		include Enumerable
+		include Comparable
+
+		class << self
+			attr_reader :duration, :format
+
+			def current
+				new(Date.today.year)
+			end
+
+			private :new, :current
+		end
+
+		attr_reader :year
 
-    def_delegator :to_range, :each
+		def_delegators :to_range,
+      *Range.instance_methods(false).reject { |m| m.to_s =~ /^(each|min|max|cover|inspect)$|^\W/ }
     
-    def to_range
-      d = to_date
-      d .. d.years_since(10).end_of_year
-    end
-        
-    def to_edtf
-      '%03dx' % (year / 10)
-    end
-  end
+
+		def initialize(year = 0)
+			self.year = year
+		end
+
+		def year=(year)
+			@year = (year / self.class.duration) * self.class.duration
+		end
+		
+		alias get year
+		alias set year=
+		
+		def cover?(other)
+			return false unless other.respond_to?(:day_precision)
+			other = other.day_precision
+			min.day_precision! <= other && other <= max.day_precision!
+		end
+		
+		def <=>(other)
+			case other
+			when Date
+				cover?(other) ? 0 : to_date <=> other
+			when Interval, Season
+				[min, max] <=> [other.min, other.max]
+			when Epoch
+				[year, self.class.duration] <=> [other.year, other.class.duration]
+			else
+				nil
+			end
+		rescue
+			nil
+		end
+
+		def ===(other)
+			(self <=> other) == 0
+		rescue
+			false
+		end
+
+		def each
+			if block_given?
+				to_range.each(&Proc.new)
+			else
+				to_enum
+			end
+		end
+
+		def to_date
+			Date.new(year).year_precision!
+		end
+
+		alias min to_date
+
+		def max
+			to_date.advance(:years => self.class.duration - 1).end_of_year
+		end
+
+		def to_range
+			min..max
+		end
+
+		def edtf
+			self.class.format % (year / self.class.duration)
+		end
+
+		alias to_s edtf
+
+	end
+
+	class Century < Epoch
+		@duration = 100.freeze
+		@format = '%02dxx'.freeze
+		
+		public_class_method :current, :new
+	end
+
+	class Decade < Epoch
+		@duration = 10.freeze
+		@format = '%03dx'.freeze
+
+		public_class_method :current, :new
+	end
 end

data/lib/edtf/interval.rb

@@ -249,7 +249,7 @@ module EDTF
     
     def <=>(other)
       case other
-      when Interval
+      when Interval, Season, Epoch
         [min, max] <=> [other.min, other.max]
       when Date
         cover?(other) ? min <=> other : 0

data/lib/edtf/parser.y

@@ -159,8 +159,10 @@ rule
     ;
 
 
-  # TODO uncertain/approximate seasons
-  season : year '-' season_number ua { result = Season.new(val[0], val[2]) }
+  season : year '-' season_number ua {
+    result = Season.new(val[0], val[2])
+    val[3].each { |ua| result.send(ua) }
+  }
 
   season_number : '2' '1' { result = 21 }
                 | '2' '2' { result = 22 }
@@ -209,12 +211,12 @@ rule
     digit digit digit X
     {
       d = val[0,3].zip([1000,100,10]).reduce(0) { |s,(a,b)| s += a * b }
-      result = Date.new(d) ... Date.new(d+10)
+      result = EDTF::Decade.new(d)
     }
     | digit digit X X
     {
       d = val[0,2].zip([1000,100]).reduce(0) { |s,(a,b)| s += a * b }
-      result = Date.new(d) ... Date.new(d+100)
+      result = EDTF::Century.new(d)
     }
     ;
 

data/lib/edtf/season.rb

@@ -1,6 +1,7 @@
 module EDTF
 
   class Season
+    extend Forwardable
     
     SEASONS = Hash[21, :spring, 22, :summer, 23, :autumn, 24, :winter].freeze
     
@@ -13,7 +14,6 @@ module EDTF
     NORTHERN_MONTHS = Hash[*NORTHERN.map { |s,ms| ms.map { |m| [m,s] } }.flatten].freeze
     SOUTHERN_MONTHS = Hash[*SOUTHERN.map { |s,ms| ms.map { |m| [m,s] } }.flatten].freeze
     
-    extend Forwardable
     
     include Comparable
     include Enumerable
@@ -26,10 +26,10 @@ module EDTF
 
     attr_reader :season, :year
     
-    attr_accessor :qualifier
+    attr_accessor :qualifier, :uncertain, :approximate
     
     def_delegators :to_range,
-      *Range.instance_methods(false).reject { |m| m.to_s =~ /^(each|eql?|hash)$/ }
+      *Range.instance_methods(false).reject { |m| m.to_s =~ /^(each|min|max|cover?|inspect)$|^\W/ }
     
     SEASONS.each_value do |s|
       define_method("#{s}?") { @season == s }
@@ -44,7 +44,7 @@ module EDTF
       alias_method("#{quarter}!", "#{season}!")
     end
 
-    
+
     def initialize(*arguments)
       arguments.flatten!
       raise ArgumentError, "wrong number of arguments (#{arguments.length} for 0..3)" if arguments.length > 3
@@ -54,7 +54,7 @@ module EDTF
         when Date
           @year, @season = arguments[0].year, NORTHERN_MONTHS[arguments[0]]
         when Symbol, String
-          @year, @season = Date.today.year, SEASONS[CODES[arguments[0].intern]]
+          @year, @season = Date.today.year, SEASONS[CODES[arguments[0].to_sym]]
         else
           self.year = arguments[0]
           @season = NORTHERN_MONTHS[Date.today.month]
@@ -66,9 +66,49 @@ module EDTF
       end
     end
 
+
+		[:uncertain, :approximate].each do |m|
+			
+			define_method("#{m}?") { !!send(m) }
+			
+			define_method("#{m}!") do
+				send("#{m}=", true)
+				self
+			end
+		end
+
+		def certain?; !uncertain; end
+		def precise?; !approximate; end
+		
+		def certain!
+			@uncertain = false
+			self
+		end
+		
+		def precise!
+			@approximate = false
+		end
+		
+		# Returns the next season.
+		def succ
+			s = dup
+			s.season = next_season_code
+			s.year = year + 1 if s.first?
+			s
+		end
+		
+		# def next(n = 1)
+		# end
+
+		def cover?(other)
+			return false unless other.respond_to?(:day_precision)
+			other = other.day_precision
+			min.day_precision! <= other && other <= max.day_precision!
+		end
+		
     def each
       if block_given?
-        to_range(&Proc.new)
+        to_range.each(&Proc.new)
         self
       else
         to_enum
@@ -88,16 +128,19 @@ module EDTF
     
     def qualified?; !!@qualifier; end
     
-    def to_s
+    def edtf
       '%04d-%2d%s' % [year, CODES[season], qualified? ? "^#{qualifier}" : '']
     end
 
-    alias edtf to_s
+    alias to_s edtf
+
     
     def <=>(other)
       case other
       when Date
         cover?(other) ? 0 : to_date <=> other
+			when Interval, Epoch
+				[min, max] <=> [other.min, other.max]
       when Season
         [year, month, qualifier] <=> [other.year, other.month, other.qualifier]
       else
@@ -117,18 +160,31 @@ module EDTF
       Date.new(year, month, 1)
     end
 
+		alias min to_date
+		
+		def max
+			to_date.months_since(2).end_of_month
+		end
+		
     # Returns a Range that covers the season (a three month period).
     def to_range
-      d = to_date
-      d .. d.months_since(2).end_of_month
+			min .. max
     end
-    
+			
     protected
     
     def month
       NORTHERN[@season][0]
     end
     
+		def season_code
+			CODES[season]
+		end
+		
+		def next_season_code(by = 1)
+			((season_code + by) % 4) + 20
+		end
+		
   end
   
 end

data/lib/edtf/version.rb

@@ -1,3 +1,3 @@
 module EDTF
-  VERSION = '0.0.9'.freeze
+  VERSION = '1.0.0'.freeze
 end

data/spec/edtf/date_spec.rb

@@ -97,7 +97,7 @@ describe 'Date/DateTime' do
 	describe '#next' do
 	  
 	  it 'returns the successor when given no argument' do
-			Date.edtf('1999').next.year.should == 2000
+			Date.edtf('1999').next[0].year.should == 2000
 	  end
 	  
 	  it 'returns an array of the next 3 elements when passed 3 as an argument' do

data/spec/edtf/epoch_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+module EDTF
+	
+	describe Decade do
+		
+		it { should_not be nil }
+
+		describe '.current' do
+			it 'creates the current decade' do
+				Decade.current.year.should == (Time.now.year / 10) * 10
+			end
+		end
+		
+		describe '#min' do
+			it 'the year 1990 should be the minimum of the 1990s' do
+				Decade.new(1999).min.should == Date.new(1990).year_precision!
+			end
+		end
+
+		describe '#max' do
+			it 'the year 1999 should be the maximum of the 1990s' do
+				Decade.new(1999).max.should == Date.new(1999).year_precision!
+			end
+			
+			it 'has year precision' do
+				Decade.new(1999).max.should be_year_precision
+			end
+		end
+
+		describe '#cover?' do
+			it '1989-12-31 should be covered by the 1980s' do
+				Decade.new(1980).should be_cover(Date.new(1989,12,31))
+			end
+		end
+		
+		describe '#to_range' do
+			
+			it 'returns a range' do
+				Decade.new.to_range.should be_instance_of(::Range)
+			end
+			
+			it 'the range starts with a date object' do
+				Decade.new.to_range.begin.should be_instance_of(::Date)
+			end
+
+			it 'the range ends with a date object' do
+				Decade.new.to_range.end.should be_instance_of(::Date)
+			end
+
+			it 'the range start has year precision' do
+				Decade.new.to_range.begin.should be_year_precision
+			end
+
+			it 'the range end has year precision' do
+				Decade.new.to_range.end.should be_year_precision
+			end
+			
+		end
+		
+		describe 'enumeration' do
+			
+			it 'always covers ten years' do
+				Decade.new.to_a.should have(10).elements
+			end
+			
+			it 'the 1970s should map to the years [1970, 1971, ... , 1979]' do
+				Decade.new(1970).map(&:year).should == [1970, 1971, 1972, 1973, 1974, 1975, 1976, 1977, 1978, 1979]
+			end
+		
+		end
+		
+	end
+
+	describe Century do
+		
+		it { should_not be nil }
+
+		describe '.current' do
+			it 'creates the current century' do
+				Century.current.year.should == (Time.now.year / 100) * 100
+			end
+		end
+		
+	end
+	
+	
+end

data/spec/edtf/parser_spec.rb

@@ -88,6 +88,20 @@ module EDTF
         d.qualifier.should == 'european'
       end
       
+			it 'parses uncertain seasons' do
+        Parser.new.parse!('2003-23?').should be_uncertain
+			end
+
+			it 'parses approximate seasons' do
+        Parser.new.parse!('2003-23~').should be_approximate
+			end
+
+			it 'parses uncertain and approximate seasons' do
+        Parser.new.parse!('2003-23?~').should be_uncertain
+        Parser.new.parse!('2003-23?~').should be_approximate
+			end
+			
+			
       it 'parses positive scientific long years' do
         Parser.new.parse('y17e7').year.should == 170000000
       end
@@ -98,14 +112,14 @@ module EDTF
       
       it 'parses masked precision date strings (decades)' do
         d = Parser.new.parse!('198x')
-        d.should include(Date.new(1983,3,12))
-        d.should_not include(Date.new(1990,1,1))
+        d.should be_cover(Date.new(1983,3,12))
+        d.should_not be_cover(Date.new(1990,1,1))
       end
 
       it 'parses masked precision date strings (centuries)' do
         d = Parser.new.parse!('18xx')
-        d.should include(Date.new(1848,1,14))
-        d.should_not include(Date.new(1799,12,31))
+        d.should be_cover(Date.new(1848,1,14))
+        d.should_not be_cover(Date.new(1799,12,31))
       end
       
       it 'parses multiple dates (years)' do

data/spec/edtf/season_spec.rb

@@ -1,7 +1,56 @@
 module EDTF
   describe 'Seasons' do
-    let(:subject) { Season.new }    
+    let(:subject) { Season.new }
+		let(:summer) { Season.new(:summer) }
+		let(:winter) { Season.new(:winter) }
     
+
+		describe 'uncertain/approximate' do
+			
+			it 'is certain by default' do
+				subject.should be_certain
+				subject.should_not be_uncertain
+			end
+
+			it 'is precise by default' do
+				subject.should be_precise
+				subject.should_not be_approximate
+			end
+			
+			describe '#approximate!' do
+				it 'makes the season approximate' do
+					subject.approximate!.should be_approximate
+					subject.approximate!.should_not be_precise
+				end
+			end
+
+			describe '#uncertain!' do
+				it 'makes the season uncertain' do
+					subject.uncertain!.should be_uncertain
+					subject.uncertain!.should_not be_certain
+				end
+			end
+			
+		end
+		
+		describe '#succ' do
+			
+			it 'returns a season' do
+				summer.succ.should be_instance_of(Season)
+			end	
+			
+			it 'it returns a season that is greater than the original one' do
+				summer.succ.should > summer
+			end
+			
+			it 'the successor of the winter season is spring of the following year' do
+				spring = winter.succ
+				spring.should be_spring
+				spring.year.should == winter.year + 1
+			end
+			
+		end
+		
     describe '#season?' do
       it 'returns true by default' do
         subject.should be_season

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: edtf
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 1.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-11-09 00:00:00.000000000 Z
+date: 2011-11-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
-  requirement: &70355024984460 !ruby/object:Gem::Requirement
+  requirement: &70108307717900 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: '3.0'
   type: :runtime
   prerelease: false
-  version_requirements: *70355024984460
+  version_requirements: *70108307717900
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70355024983720 !ruby/object:Gem::Requirement
+  requirement: &70108307716720 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,10 +32,10 @@ dependencies:
         version: '0.9'
   type: :development
   prerelease: false
-  version_requirements: *70355024983720
+  version_requirements: *70108307716720
 - !ruby/object:Gem::Dependency
   name: racc
-  requirement: &70355024982860 !ruby/object:Gem::Requirement
+  requirement: &70108307715280 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,10 +43,10 @@ dependencies:
         version: '1.4'
   type: :development
   prerelease: false
-  version_requirements: *70355024982860
+  version_requirements: *70108307715280
 - !ruby/object:Gem::Dependency
   name: cucumber
-  requirement: &70355024981980 !ruby/object:Gem::Requirement
+  requirement: &70108307714220 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -54,10 +54,10 @@ dependencies:
         version: '1.0'
   type: :development
   prerelease: false
-  version_requirements: *70355024981980
+  version_requirements: *70108307714220
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70355024981220 !ruby/object:Gem::Requirement
+  requirement: &70108307713500 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -65,10 +65,10 @@ dependencies:
         version: '2.6'
   type: :development
   prerelease: false
-  version_requirements: *70355024981220
+  version_requirements: *70108307713500
 - !ruby/object:Gem::Dependency
   name: ZenTest
-  requirement: &70355024980360 !ruby/object:Gem::Requirement
+  requirement: &70108307712900 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -76,7 +76,7 @@ dependencies:
         version: '4.6'
   type: :development
   prerelease: false
-  version_requirements: *70355024980360
+  version_requirements: *70108307712900
 description: A Ruby implementation of the Extended Date/Time Format (EDTF).
 email:
 - http://sylvester.keil.or.at
@@ -127,7 +127,7 @@ files:
 - spec/edtf/uncertainty_spec.rb
 - spec/spec_helper.rb
 - lib/edtf/parser.rb
-homepage: http://inukshuk.github.com/edtf-ruby
+homepage: http://github.com/inukshuk/edtf-ruby
 licenses:
 - FreeBSD
 post_install_message: 
@@ -149,7 +149,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1918843685167052448
+      hash: -2732104332429493129
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -158,7 +158,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1918843685167052448
+      hash: -2732104332429493129
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.10