edtf 0.0.3 → 0.0.4

data/Gemfile

@@ -6,3 +6,6 @@ group :debug do
 	gem 'ruby-debug', :platforms => [:mri_18, :jruby]
 	gem 'rbx-trepanning', :platforms => [:rbx]
 end
+
+# active_support requires this
+gem 'i18n'

data/edtf.gemspec

@@ -15,6 +15,8 @@ Gem::Specification.new do |s|
   s.description = 'An Extended Date/Time Format (EDTF) Parser for Ruby.'
   s.license     = 'FreeBSD'
 
+  s.add_runtime_dependency('activesupport', ['~>3.0'])
+  
   s.add_development_dependency('rake', ['~>0.9'])
   s.add_development_dependency('racc', ['~>1.4'])
   s.add_development_dependency('cucumber', ['~>1.0'])

data/features/parser/dates.feature

@@ -3,7 +3,7 @@ Feature: EDTF parser parses date strings
   In order to use dates in EDTF
   As a user of edtf-ruby
   I want to parse date strings formatted in EDTF
-
+    
   Scenario Outline: EDTF parses a date string
     When I parse the string "<string>"
     Then the year should be "<year>"

data/features/parser/intervals.feature

@@ -4,16 +4,15 @@ Feature: EDTF parses ISO 8601 interval strings
 	
 	Scenario Outline: parse intervals
 		When I parse the string "<string>"
-		Then the interval should start at "<from>"
-		And the interval should end at "<to>"
+		Then the interval should include the date "<date>"
 	
 	@004 @level0
 	Scenarios: specification intervals
-		| string                | from       | to         |
-		| 1964/2008             | 1964-01-01 | 2008-01-01 |
-		| 2004-06/2006-08       | 2004-06-01 | 2006-08-01 |
-		| 2004-01-01/2004-01-02 | 2004-01-01 | 2004-01-02 |
-		| 2004-02-01/2005-02-08 | 2004-02-01 | 2005-02-08 |
-		| 2004-02-01/2005-02    | 2004-02-01 | 2005-02-01 |
-		| 2004-02-01/2005       | 2004-02-01 | 2005-01-01 |
-		| 2005/2006-02          | 2005-01-01 | 2006-02-01 |
+		| string                | date       |
+		| 1964/2008             | 1964-01-01 |
+		| 2004-06/2006-08       | 2006-08-31 |
+		| 2004-01-01/2004-01-02 | 2004-01-01 |
+		| 2004-02-01/2005-02-08 | 2005-02-08 |
+		| 2004-02-01/2005-02    | 2004-12-01 |
+		| 2004-02-01/2005       | 2005-12-31 |
+		| 2005/2006-02          | 2005-01-01 |

data/features/print/level_1_edtf.feature

@@ -0,0 +1,68 @@
+Feature: Print Date/Time objects as Level 1 EDTF strings
+  As a Ruby programmer
+  I want to convert Date/Time objects to EDTF strings
+  
+  Scenario: Convert simple dates
+    Given the date "2004-08-12"
+    When I convert the date
+    Then the EDTF string should be "2004-08-12"
+
+	Scenario: Convert simple dates with precision
+		Given the date "1980-08-24" with precision set to "day"
+		When I convert the date
+		Then the EDTF string should be "1980-08-24"
+		Given the date "1980-08-24" with precision set to "month"
+		When I convert the date
+		Then the EDTF string should be "1980-08"
+		Given the date "1980-08-24" with precision set to "year"
+		When I convert the date
+		Then the EDTF string should be "1980"
+
+	Scenario: Date Roundtrips
+		When I parse the string "2001-02-03"
+		When I convert the date
+		Then the EDTF string should be "2001-02-03"
+		When I parse the string "2001-02"
+		When I convert the date
+		Then the EDTF string should be "2001-02"
+		When I parse the string "2001"
+		When I convert the date
+		Then the EDTF string should be "2001"
+		When I parse the string "-9909"
+		When I convert the date
+		Then the EDTF string should be "-9909"
+		When I parse the string "0000"
+		When I convert the date
+		Then the EDTF string should be "0000"
+
+	Scenario: DateTime Roundtrips
+		When I parse the string "2001-02-03T09:30:01"
+		When I convert the date
+		Then the EDTF string should be "2001-02-03T09:30:01+00:00"
+		When I parse the string "2004-01-01T10:10:10Z"
+		When I convert the date
+		Then the EDTF string should be "2004-01-01T10:10:10+00:00"
+		When I parse the string "2004-01-01T10:10:10+05:00"
+		When I convert the date
+		Then the EDTF string should be "2004-01-01T10:10:10+05:00"
+
+	Scenario: Interval Roundtrips
+		When I parse the string "1964/2008"
+		When I convert the date
+		Then the EDTF string should be "1964/2008"
+		When I parse the string "2004-06/2006-08"
+		When I convert the date
+		Then the EDTF string should be "2004-06/2006-08"
+		When I parse the string "2004-02-01/2005-02-08"
+		When I convert the date
+		Then the EDTF string should be "2004-02-01/2005-02-08"
+		When I parse the string "2004-02-01/2005-02"
+		When I convert the date
+		Then the EDTF string should be "2004-02-01/2005-02"
+		When I parse the string "2004-02-01/2005"
+		When I convert the date
+		Then the EDTF string should be "2004-02-01/2005"		
+		When I parse the string "2005/2006-02"
+		When I convert the date
+		Then the EDTF string should be "2005/2006-02"
+		

data/features/print/level_2_edtf.feature

@@ -0,0 +1,8 @@
+Feature: Print Date/Time objects as Level 2 EDTF strings
+  As a Ruby programmer
+  I want to convert Date/Time objects to EDTF strings
+  
+	Scenario: Uncertain or approximate dates
+		When I parse the string "2001?"
+		When I convert the date
+		Then the EDTF string should be "2001?"

data/features/step_definitions/edtf_steps.rb

@@ -1,80 +1,98 @@
+Given /^the date "([^"]*)"(?: with precision set to "([^"]*)")?$/ do |date, precision|
+  @date = Date.parse(date)
+	@date.precision = precision unless precision.nil?
+end
+
+When /^I convert the date$/ do
+  @string = @date.edtf
+end
+
+Then /^the EDTF String should be "([^"]*)"$/i do |edtf|
+  @string.should == edtf
+end
+
 When /^I parse the string "([^"]*)"$/ do |string|
-  @edtf = EDTF.parse(string)
+  @date = EDTF.parse(string)
 end
 
 Then /^the year should be "([^"]*)"$/ do |year|
-  @edtf.year.should == year.to_i
+  @date.year.should == year.to_i
 end
 
 Then /^the month should be "([^"]*)"$/ do |month|
-  @edtf.month.should == month.to_i
+  @date.month.should == month.to_i
 end
 
 Then /^the day should be "([^"]*)"$/ do |day|
-  @edtf.day.should == day.to_i
+  @date.day.should == day.to_i
 end
 
 Then /^the hours should be "([^"]*)"$/ do |hours|
-  @edtf.hour.should == hours.to_i
+  @date.hour.should == hours.to_i
 end
 
 Then /^the year should be "([^"]*)" \(UTC\)$/ do |year|
-  @edtf.to_time.utc.year.should == year.to_i
+  @date.to_time.utc.year.should == year.to_i
 end
 
 Then /^the month should be "([^"]*)" \(UTC\)$/ do |month|
-  @edtf.to_time.utc.month.should == month.to_i
+  @date.to_time.utc.month.should == month.to_i
 end
 
 Then /^the day should be "([^"]*)" \(UTC\)$/ do |day|
-  @edtf.to_time.utc.day.should == day.to_i
+  @date.to_time.utc.day.should == day.to_i
 end
 
 Then /^the hours should be "([^"]*)" \(UTC\)$/ do |hours|
-  @edtf.to_time.utc.hour.should == hours.to_i
+  @date.to_time.utc.hour.should == hours.to_i
 end
 
 
 Then /^the minutes should be "([^"]*)"$/ do |minutes|
-  @edtf.min.should == minutes.to_i
+  @date.min.should == minutes.to_i
 end
 
 Then /^the seconds should be "([^"]*)"$/ do |seconds|
-  @edtf.sec.should == seconds.to_i
+  @date.sec.should == seconds.to_i
 end
 
 Then /^the duration should range from "([^"]*)" to "([^"]*)"$/ do |from,to|
-  [@edtf.begin.year.to_s, @edtf.end.year.to_s].should == [from,to]
+  [@date.begin.year.to_s, @date.end.year.to_s].should == [from,to]
 end
 
 Then /^the interval should start at "([^"]*)"$/ do |date|
-  @edtf.begin.to_s.should == date
+  @date.begin.to_s.should == date
 end
 
 Then /^the interval should end at "([^"]*)"$/ do |date|
-  @edtf.end.to_s.should == date
+  @date.end.to_s.should == date
+end
+
+Then /^the interval should include the date "([^"]*)"$/ do |date|
+  @date.should include(Date.parse(date))
 end
 
+
 Then /^the date should be uncertain\? "([^"]*)"$/ do |arg1|
-  @edtf.uncertain?.should == !!(arg1 =~ /y(es)?/i)
+  @date.uncertain?.should == !!(arg1 =~ /y(es)?/i)
 end
 
 Then /^the year should be uncertain\? "([^"]*)"$/ do |arg1|
-  @edtf.uncertain?(:year).should == !!(arg1 =~ /y(es)?/i)
+  @date.uncertain?(:year).should == !!(arg1 =~ /y(es)?/i)
 end
 
 Then /^the month should be uncertain\? "([^"]*)"$/ do |arg1|
-  @edtf.uncertain?(:month).should == !!(arg1 =~ /y(es)?/i)
+  @date.uncertain?(:month).should == !!(arg1 =~ /y(es)?/i)
 end
 
 Then /^the day should be uncertain\? "([^"]*)"$/ do |arg1|
-  @edtf.uncertain?(:day).should == !!(arg1 =~ /y(es)?/i)
+  @date.uncertain?(:day).should == !!(arg1 =~ /y(es)?/i)
 end
 
 Then /^the date should be approximate\? "([^"]*)"$/ do |arg1|
-  @edtf.approximate?.should == !!(arg1 =~ /y(es)?/i)
+  @date.approximate?.should == !!(arg1 =~ /y(es)?/i)
 end
 
 Then /^the unspecified string code be "([^"]*)"$/ do |arg1|
-  @edtf.unspecified.to_s.should == arg1
+  @date.unspecified.to_s.should == arg1
 end

data/lib/edtf.rb

@@ -33,13 +33,21 @@ autoload :Rational, 'rational'
 
 require 'forwardable'
 
+require 'active_support/core_ext/date/calculations'
+require 'active_support/core_ext/date_time/calculations'
+require 'active_support/core_ext/time/calculations'
+
+
+require 'active_support/core_ext/date/conversions'
+
 require 'edtf/compatibility'
 
 require 'edtf/version'
 require 'edtf/uncertainty'
-require 'edtf/seasons'
 require 'edtf/date'
 require 'edtf/date_time'
+require 'edtf/epoch'
+require 'edtf/season'
 require 'edtf/interval'
 require 'edtf/parser'
 require 'edtf/extensions'

data/lib/edtf/compatibility.rb

@@ -1,11 +1,10 @@
 
-unless DateTime.respond_to?(:to_time)
-  require 'time'
-  
-  class DateTime
-    def to_time
-      Time.parse(to_s)
-    end
-  end
-  
-end
+# unless DateTime.respond_to?(:to_time)
+#   require 'time'
+#   
+#   class DateTime
+#     def to_time
+#       Time.parse(to_s)
+#     end
+#   end  
+# end

data/lib/edtf/date.rb

@@ -1,140 +1,187 @@
-module EDTF
+class Date
   
   PRECISIONS = [:year, :month, :day].freeze
+	FORMATS = %w{ %04d %02d %02d }.freeze
 
-  module ExtendedDate
-    
-    extend Forwardable
-    
-    include Seasons
-    
-    attr_accessor :calendar
-    
-    attr_reader :precision
-        
-    def precision=(precision)
-      raise ArgumentError, "invalid precision #{precision.inspect}" unless PRECISIONS.include?(precision.to_sym)
-      @precision = precision.to_sym
-      update_precision_filter[-1]
-    end
-    
-    def self.included(base)
-      base.extend(ClassMethods)
+  EXTENDED_ATTRIBUTES = %w{ calendar precision uncertain approximate
+    unspecified }.map(&:intern).freeze
+   	
+  extend Forwardable  
+  
+  class << self
+    def edtf(input, options = {})
+      ::EDTF::Parser.new(options).parse(input)
     end
-    
-    def uncertain
-      @uncertain ||= Uncertainty.new
+  end
+  
+  attr_accessor :calendar
+  
+  PRECISIONS.each do |p|
+    define_method("#{p}_precision?") { @precision == p }
+    define_method("#{p}_precision!") { @precision =  p }
+  end
+  
+  def dup
+    d = super
+    d.uncertain = uncertain.dup
+    d.approximate = approximate.dup
+    d.unspecified = unspecified.dup
+    d
+  end
+  
+  # Alias change method from Active Support.
+  alias original_change change
+  
+  # Returns a new Date where one or more of the elements have been changed according to the +options+ parameter.
+  def change(options)
+    d = original_change(options)
+    EXTENDED_ATTRIBUTES.each do |attribute|
+      d.send("#{attribute}=", options[attribute] || send(attribute))
     end
+    d
+  end
+  
+  # Returns this Date's precision.
+  def precision
+    @precision ||= :day
+  end
+  
+  def precision=(precision)
+    precision = precision.intern
+    raise ArgumentError, "invalid precision #{precision.inspect}" unless PRECISIONS.include?(precision)
+    @precision = precision
+    update_precision_filter[-1]
+  end
+  
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+  
+  def uncertain
+    @uncertain ||= EDTF::Uncertainty.new
+  end
 
-    def approximate
-      @approximate ||= Uncertainty.new
-    end
+  def approximate
+    @approximate ||= EDTF::Uncertainty.new
+  end
 
-    def unspecified
-      @unspecified ||= Unspecified.new
-    end
-    
-    def_delegators :uncertain, :uncertain?, :certain?
+  def unspecified
+    @unspecified ||= EDTF::Unspecified.new
+  end
+  
+  def_delegators :uncertain, :uncertain?, :certain?
 
-    def certain!(*arguments)
-      uncertain.certain!(*arguments)
-      self
-    end
-    
-    def uncertain!(*arguments)
-      uncertain.uncertain!(*arguments)
-      self
-    end
+  def certain!(*arguments)
+    uncertain.certain!(*arguments)
+    self
+  end
+  
+  def uncertain!(*arguments)
+    uncertain.uncertain!(*arguments)
+    self
+  end
 
-    def approximate?(*arguments)
-      approximate.uncertain?(*arguments)
-    end
-    
-    alias approximately? approximate?
-    
-    def approximate!(*arguments)
-      approximate.uncertain!(*arguments)
-      self
-    end
-    
-    alias approximately! approximate!
-    
-    def precise?(*arguments)
-      !approximate?(*arguments)
-    end
-    
-    alias precisely? precise?
+  def approximate?(*arguments)
+    approximate.uncertain?(*arguments)
+  end
+  
+  alias approximately? approximate?
+  
+  def approximate!(*arguments)
+    approximate.uncertain!(*arguments)
+    self
+  end
+  
+  alias approximately! approximate!
+  
+  def precise?(*arguments)
+    !approximate?(*arguments)
+  end
+  
+  alias precisely? precise?
 
-    def precise!(*arguments)
-      approximate.certain!(*arguments)
-      self
-    end
+  def precise!(*arguments)
+    approximate.certain!(*arguments)
+    self
+  end
 
-    alias precisely! precise!
-    
-    def_delegators :unspecified, :unspecified?, :specified?, :unsepcific?, :specific?
-    
-    def unspecified!(*arguments)
-      unspecified.unspecified!(*arguments)
-      self
-    end
+  alias precisely! precise!
+  
+  def_delegators :unspecified, :unspecified?, :specified?, :unsepcific?, :specific?
+  
+  def unspecified!(*arguments)
+    unspecified.unspecified!(*arguments)
+    self
+  end
 
-    alias unspecific! unspecified!
+  alias unspecific! unspecified!
 
-    def specified!(*arguments)
-      unspecified.specified!(*arguments)
-      self
-    end
+  def specified!(*arguments)
+    unspecified.specified!(*arguments)
+    self
+  end
 
-    alias specific! specified!
-    
-    def to_edtf
-      "TODO"
-    end
+  alias specific! specified!
+  
+  def season?; false; end
+  
+  def season
+    Season.new(self)
+  end
+  
+  def edtf
+    FORMATS.take(values.length).join('-') % values
+  end
 
-    # TODO take precision into account
-    def next
-      super
-    end
-    
-    def values
-      precision_filter.map { |p| send(p) }
-    end
-    
-    # Returns the same date with negated year        
-    def negate
-      v = values
-      y = -1 * v.shift
-      self.class.new(y, *v) # TODO copy extended attributes
-    end
-    
-    alias -@ negate
-    
-    
-    private
-    
-    def precision_filter
-      @precision_filter ||= update_precision_filter
-    end
-    
-    def update_precision_filter
-      case @precision
-      when :year
-        [:year]
-      when :month
-        [:year,:month]
-      else
-        [:year,:month,:day]
-      end
-    end
+	alias to_edtf edtf
+	
+  def next
+    send("next_#{precision}")
+  end
+  
+  # def succ
+  # end
 
-    
-    module ClassMethods  
-      def edtf(input, options = {})
-        ::EDTF::Parser.new(options).parse(input)
-      end
+  # def ==(other)
+  # end
+
+  # def <=>(other)
+  # end
+
+  # def ===(other)
+  # end
+  
+  def values
+    precision_filter.map { |p| send(p) }
+  end
+  
+  # Returns the same date with negated year        
+  def negate
+		change(:year => year * -1)
+  end
+  
+  alias -@ negate
+  
+  
+  private
+
+  def precision_filter
+    @precision_filter ||= update_precision_filter
+  end
+  
+  def update_precision_filter
+    case @precision
+    when :year
+      [:year]
+    when :month
+      [:year,:month]
+    else
+      [:year,:month,:day]
     end
-    
   end
+    
+  protected
+  
+  attr_writer :uncertain, :unspecified, :approximate
   
-end
+end