edtf 0.0.3 → 0.0.4

data/lib/edtf/date_time.rb

@@ -1,15 +1,9 @@
-module EDTF
-  
-  module ExtendedDateTime
-
-    def to_edtf
-      super
-    end    
-
-    def values
-      super + [hour,minute,second,offset]
-    end
-    
+class DateTime
+	
+	alias edtf iso8601
+	alias to_edtf edtf
+	
+  def values
+    super + [hour,minute,second,offset]
   end
-  
 end

data/lib/edtf/epoch.rb

@@ -0,0 +1,57 @@
+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
+
+    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
+
+    def_delegator :to_range, :each
+    
+    def to_range
+      d = to_date
+      d .. d.years_since(10).end_of_year
+    end
+        
+    def to_edtf
+      '%03dx' % (year / 10)
+    end
+  end
+end

data/lib/edtf/extensions.rb

@@ -1,8 +0,0 @@
-
-class Date
-  include EDTF::ExtendedDate
-end
-
-class DateTime
-  include EDTF::ExtendedDateTime
-end

data/lib/edtf/interval.rb

@@ -57,10 +57,30 @@ module EDTF
       when unknown_end?
         nil
       else
-        Range.new(unknown_start? ? Date.new : from, to)
+        Range.new(unknown_start? ? Date.new : @from, bounds)
       end
     end
     
+    def bounds
+      case
+      when open_end?, to.day_precision? 
+        to
+      when to.month_precision?
+        to.end_of_month
+      else
+        to.end_of_year
+      end
+    end
+   
+  	def edtf
+			[
+				@from.send(@from.respond_to?(:edtf) ? :edtf : :to_s),
+				@to.send(@to.respond_to?(:edtf) ? :edtf : :to_s)
+			].join('/')
+		end
+		
+		alias to_s edtf
+		
   end
   
 end

data/lib/edtf/parser.y

@@ -123,7 +123,7 @@ rule
             | long_year digit { result = 10 * val[0] + val[1] }
 
 
-  season : year MINUS season_number { result = Date.new(val[0]); result.season = val[2]; result.precision = :year }
+  season : year MINUS season_number { result = Season.new(val[0], val[2]) }
 
   season_number : D2 D1 { result = 21 }
                 | D2 D2 { result = 22 }
@@ -283,85 +283,71 @@ require 'strscan'
   
   def parse(input)
     @yydebug = @options[:debug] || ENV['DEBUG']
-    scan(input)
+    @src = StringScanner.new(input)
     do_parse
   end
   
-  def next_token
-    @stack.shift
-  end
-
   def on_error(tid, val, vstack)
     warn "failed to parse extended date time %s (%s) %s" % [val.inspect, token_to_str(tid) || '?', vstack.inspect]
   end
 
-  def scan(input)
-    @src = StringScanner.new(input)
-    @stack = []
-    tokenize
-  end
-
-  private
-
-  def tokenize
-    until @src.eos?
-      case
-      # when @src.scan(/\s+/)
-        # ignore whitespace
-      when @src.scan(/\(/)
-        @stack << [:LP, @src.matched]
-      when @src.scan(/\)/)
-        @stack << [:RP, @src.matched]
-      when @src.scan(/\[/)
-        @stack << [:LSQUARE, @src.matched]
-      when @src.scan(/\]/)
-        @stack << [:RSQUARE, @src.matched]
-      when @src.scan(/\{/)
-        @stack << [:LBRACE, @src.matched]
-      when @src.scan(/\}/)
-        @stack << [:RBRACE, @src.matched]
-      when @src.scan(/T/)
-        @stack << [:T, @src.matched]
-      when @src.scan(/Z/)
-        @stack << [:Z, @src.matched]
-      when @src.scan(/\?/)
-        @stack << [:UNCERTAIN, @src.matched]
-      when @src.scan(/~/)
-        @stack << [:APPROXIMATE, @src.matched]
-      when @src.scan(/open/i)
-        @stack << [:OPEN, @src.matched]
-      when @src.scan(/unkn?own/i) # matches 'unkown' typo too
-        @stack << [:UNKNOWN, @src.matched]
-      when @src.scan(/u/)
-        @stack << [:UNSPECIFIED, @src.matched]
-      when @src.scan(/x/i)
-        @stack << [:X, @src.matched]
-      when @src.scan(/y/)
-        @stack << [:LONGYEAR, @src.matched]
-      when @src.scan(/e/)
-        @stack << [:E, @src.matched]
-      when @src.scan(/\+/)
-        @stack << [:PLUS, @src.matched]
-      when @src.scan(/-/)
-        @stack << [:MINUS, @src.matched]
-      when @src.scan(/:/)
-        @stack << [:COLON, @src.matched]
-      when @src.scan(/\//)
-        @stack << [:SLASH, @src.matched]
-      when @src.scan(/\s*\.\.\s*/)
-        @stack << [:DOTS, '..']
-      when @src.scan(/\s*,\s*/)
-        @stack << [:COMMA, ',']
-      when @src.scan(/\^\w+/)
-        @stack << [:CARET, @src.matched[1..-1]]
-      when @src.scan(/\d/)
-        @stack << [['D', @src.matched].join.intern, @src.matched]
-      else @src.scan(/./)
-        @stack << [:UNMATCHED, @src.rest]
-      end
-    end
-  
-    @stack
+  def next_token
+		case
+		when @src.eos?
+			nil
+	  # when @src.scan(/\s+/)
+	    # ignore whitespace
+	  when @src.scan(/\(/)
+	    [:LP, @src.matched]
+	  when @src.scan(/\)/)
+	    [:RP, @src.matched]
+	  when @src.scan(/\[/)
+	    [:LSQUARE, @src.matched]
+	  when @src.scan(/\]/)
+	    [:RSQUARE, @src.matched]
+	  when @src.scan(/\{/)
+	    [:LBRACE, @src.matched]
+	  when @src.scan(/\}/)
+	    [:RBRACE, @src.matched]
+	  when @src.scan(/T/)
+	    [:T, @src.matched]
+	  when @src.scan(/Z/)
+	    [:Z, @src.matched]
+	  when @src.scan(/\?/)
+	    [:UNCERTAIN, @src.matched]
+	  when @src.scan(/~/)
+	    [:APPROXIMATE, @src.matched]
+	  when @src.scan(/open/i)
+	    [:OPEN, @src.matched]
+	  when @src.scan(/unkn?own/i) # matches 'unkown' typo too
+	    [:UNKNOWN, @src.matched]
+	  when @src.scan(/u/)
+	    [:UNSPECIFIED, @src.matched]
+	  when @src.scan(/x/i)
+	    [:X, @src.matched]
+	  when @src.scan(/y/)
+	    [:LONGYEAR, @src.matched]
+	  when @src.scan(/e/)
+	    [:E, @src.matched]
+	  when @src.scan(/\+/)
+	    [:PLUS, @src.matched]
+	  when @src.scan(/-/)
+	    [:MINUS, @src.matched]
+	  when @src.scan(/:/)
+	    [:COLON, @src.matched]
+	  when @src.scan(/\//)
+	    [:SLASH, @src.matched]
+	  when @src.scan(/\s*\.\.\s*/)
+	    [:DOTS, '..']
+	  when @src.scan(/\s*,\s*/)
+	    [:COMMA, ',']
+	  when @src.scan(/\^\w+/)
+	    [:CARET, @src.matched[1..-1]]
+	  when @src.scan(/\d/)
+	    [['D', @src.matched].join.intern, @src.matched]
+	  else @src.scan(/./)
+	    [:UNMATCHED, @src.rest]
+	  end
   end
 
 

data/lib/edtf/season.rb

@@ -0,0 +1,133 @@
+module EDTF
+
+  class Season
+    
+    SEASONS = Hash[21, :spring, 22, :summer, 23, :autumn, 24, :winter].freeze
+    
+    CODES = Hash.new { |h,k| h.fetch(k.to_sym, nil) }.merge(
+      SEASONS.invert).merge({ :fall => 23 }).freeze
+    
+    NORTHERN = Hash[:spring, [3,4,5], :summer, [6,7,8], :autumn, [9,10,11], :winter, [12,1,2]].freeze
+    SOUTHERN = Hash[:autumn, [3,4,5], :winter, [6,7,8], :spring, [9,10,11], :summer, [12,1,2]].freeze
+    
+    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
+    
+    class << self
+      def current
+        Date.today.season
+      end
+    end
+
+    attr_reader :season, :year
+    
+    attr_accessor :qualifier
+    
+    def_delegators :to_range, :each
+    
+    SEASONS.each_value do |s|
+      define_method("#{s}?") { @season == s }
+      define_method("#{s}!") { @season =  s }
+    end
+    
+    alias fall? autumn?
+    alias fall! autumn!
+    
+    [:first, :second, :third, :fourth].zip(SEASONS.values).each do |quarter, season|
+      alias_method("#{quarter}?", "#{season}?")
+      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
+      
+      if arguments.length == 1
+        case arguments[0]
+        when Date
+          @year, @season = arguments[0].year, NORTHERN_MONTHS[arguments[0]]
+        when Symbol, String
+          @year, @season = Date.today.year, SEASONS[CODES[arguments[0].intern]]
+        else
+          self.year = arguments[0]
+          @season = NORTHERN_MONTHS[Date.today.month]
+        end
+      else
+        self.year      = arguments[0] || Date.today.year
+        self.season    = arguments[1] || NORTHERN_MONTHS[Date.today.month]
+        self.qualifier = qualifier
+      end
+    end
+
+    def year=(new_year)
+      @year = new_year.to_i
+    end
+    
+    def season=(new_season)
+      @season = SEASONS[new_season] || SEASONS[CODES[new_season]] ||
+        raise(ArgumentError, "unknown season/format: #{new_season.inspect})")
+    end
+
+    def season?; true; end
+    
+    def qualified?; !!@qualifier; end
+    
+    def to_s
+      '%04d-%2d%s' % [year, CODES[season], qualified? ? "^#{qualifier}" : '']
+    end
+
+    alias to_edtf to_s
+    
+    def <=>(other)
+      case other
+      when Date
+        include?(other) ? 0 : to_date <=> other
+      when Season
+        [year, month, qualifier] <=> [other.year, other.month, other.qualifier]
+      else
+        nil
+      end
+    rescue
+      nil
+    end
+    
+    def ===(other)
+      (self <=> other) == 0
+    rescue
+      false
+    end
+    
+    def to_date
+      Date.new(year, month)
+    end
+
+    # def include?(other)
+    #   case other
+    #   when Date
+    #     d = to_date
+    #     other >= d && other <= d.months_since(3).end_of_month
+    #   else
+    #     false
+    #   end
+    # end
+    
+    def to_range
+      d = to_date
+      d .. d.months_since(3).end_of_month
+    end
+    
+    protected
+    
+    def month
+      NORTHERN[@season][0]
+    end
+    
+  end
+  
+end

data/lib/edtf/uncertainty.rb

@@ -1,6 +1,7 @@
 module EDTF
  
   class Uncertainty < Struct.new(:year, :month, :day, :hour, :minute, :second)
+        
     def uncertain?(parts = members)
       [parts].flatten.any? { |p| !!send(p) }
     end

data/lib/edtf/version.rb

@@ -1,3 +1,3 @@
 module EDTF
-  VERSION = '0.0.3'.freeze
+  VERSION = '0.0.4'.freeze
 end

data/spec/edtf/date_spec.rb

@@ -0,0 +1,118 @@
+describe 'Date/DateTime' do
+
+  describe 'class methods' do
+    it 'responds to edtf' do
+      Date.should respond_to(:edtf)
+    end
+  end
+  
+  describe 'instance methods' do
+    [:uncertain?, :approximate?, :unspecified?, :uncertain, :approximate, :unspecified].each do |method|
+      it "responds to #{method}" do
+        Date.new.respond_to?(method).should == true
+      end
+    end
+  end
+  
+  describe '#dup' do
+    let(:date) { Date.edtf('2004-09?~') }
+    
+    it 'copies all date values' do
+      date.dup.to_s == '2004-09-01'
+    end
+    
+    it 'copies uncertainty' do
+      date.dup.should be_uncertain
+    end
+
+    it 'copies approximate' do
+      date.dup.should be_approximate
+    end
+
+    it 'copies precision' do
+      date.dup.precision.should == :month
+    end
+    
+    it 'copies uncertainty by value' do
+      lambda { date.dup.certain! }.should_not change { date.uncertain? }
+    end
+    
+  end
+  
+	describe '#negate' do
+    let(:date) { Date.edtf('2004?') }
+		
+		it 'should return a new date with the negated year' do
+			date.negate.year.should == (date.year * -1)
+		end
+		
+		it 'should return a new date with the same month and day' do
+			date.negate.month.should == date.month
+			date.negate.day.should == date.day
+		end
+		
+		it 'should return a new date with the same precision' do
+			date.negate.precision.should == date.precision
+		end
+	end
+	
+  describe '#change' do
+    let(:date) { Date.edtf('2004-09?~') }
+
+    it 'returns a copy of the date if given empty option hash' do
+      date.change({}).should == date
+      date.change({}).should_not equal(date)
+    end
+    
+    describe 'when given a new year' do
+      let(:changeset) { { :year => 1999 } }
+      
+      it 'returns a new date instance with the changed year' do
+        date.change(changeset).year.should == 1999
+      end
+      
+    end
+
+    describe 'when given a new precision' do
+      let(:changeset) { { :precision => :year } }
+      
+      it 'returns a new date instance with the changed precision' do
+        date.change(changeset).precision.should == :year
+      end
+
+    end
+
+    it 'copies extended values by value' do
+      lambda { date.change({}).approximate! }.should_not change { date.approximate? }
+    end
+    
+  end
+  
+  describe '#uncertain?' do
+    
+    let(:date) { Date.new }
+    
+    it { Date.new.should_not be_uncertain }
+
+    [:year, :month, :day].each do |part|
+      it "should not be uncertain by default (#{part})" do
+        Date.new.uncertain?(part).should == false
+      end
+
+      it "should be uncertain if set to uncertain (#{part})" do
+        date.uncertain.send("#{part}=", true)
+        date.uncertain?(part).should == true
+      end
+
+      ([:year, :month, :day] - [part]).each do |other|
+        it "#{other} should not be uncertain if #{part} is uncertain" do
+          date.uncertain.send("#{part}=", true)
+          date.uncertain?(other).should == false
+        end
+      end
+      
+    end
+    
+  end
+    
+end