eventual 0.4.9 → 0.5.0

data/lib/eventual.rb

@@ -1,193 +1,7 @@
+require 'rubygems'
+require 'treetop'
 require 'date'
-require 'iconv'
-require 'strscan'
 
-module Eventual
-  class WdayMatchError < StandardError; end
-  
-  
-  VERSION = '0.4.9'
-  extend self
-
-  WDAY_LIST    = %w(domingo lunes martes miércoles jueves viernes sábado).freeze
-  MESES        = %w(enero febrero marzo abril mayo junio julio agosto septiembre octubre noviembre diciembre).unshift(nil).freeze
-  DIAS_DE_LA_SEMANA  = WDAY_LIST.map{ |d| d.match(/s$/) ? d : "#{d}s?" }
-  
-  def rango_de a, b = nil
-    a = a.join('|') if Array === a
-    b ||= a
-    /(?:de |del )?(?:#{ a }) (?:a|al) (?:#{ b })/
-  end
-
-  def lista_de elementos
-    elementos = elementos.join('|') if Array === elementos
-    /(?:#{ elementos })  # Primer elemento -requerido-
-    (?:                           # Cualquier número de 
-      (?-x:, | y )                  # concatenador
-      (?:#{ elementos })            # y elemento.
-     )*/ix
-  end
-  
-  def plural_opcional elementos
-    elementos.map{ |d| d.match(/s$/) ? d : "#{d}s?" }
-  end
-
-  year         = /(?-x:del |de )?(\d{4})/i
-  horarios     = /a las (#{ lista_de '\d{1,2}:\d{2}' })(?: horas| hrs)?/i
-  
-
-  DAY_LIST = /
-               (#{ lista_de %r"(?:(?:#{ DIAS_DE_LA_SEMANA.join('|') }) )?\d{1,2}" })\s
-               de\s(#{ MESES.compact.join('|') })         # Mes
-               (?:\s#{ year })?                           # Año opcional
-               (\s#{ horarios })?                         # Hora opcional
-             /ixo
-
-  DAY_PERIOD =  /
-                  (?:
-                    (
-                      (?:#{ rango_de DIAS_DE_LA_SEMANA })\s
-                      |
-                      (?:#{ lista_de DIAS_DE_LA_SEMANA })\s
-                    )
-                    (?-x:de |del )
-                  )?
-                  (?-x:(?:de |del )?(?:(#{ DIAS_DE_LA_SEMANA.join('|') }) )?(\d{1,2})(?: de (#{ MESES.compact.join('|') })(?: #{ year })?)?)                                                   
-                  (?-x: (?:a|al) (?:(#{ DIAS_DE_LA_SEMANA.join('|') }) )?(\d{1,2}) de (#{ MESES.compact.join('|') })(?: #{ year })?)
-                  (?:\s#{ horarios })?
-                /ixo 
-                 
-  WHOLE_MONTH = / 
-                 ( # Dias de la semana opcionales
-                   (?-x:los |todos los )?
-                   (?:
-                     (?:#{ rango_de DIAS_DE_LA_SEMANA })
-                     |
-                     (?:#{ lista_de DIAS_DE_LA_SEMANA })
-                   )\s
-                   (?-x:de|durante|durante todo)\s
-                 )?
-                (?:
-                   (?:#{ rango_de %r"(#{ MESES.compact.join('|') })(?:\s#{ year })?" })
-                   |
-                   (#{ lista_de MESES.compact })(?:\s#{ year })?
-                )
-                (?:\s#{ horarios })?  # Hora opcional
-               /ixo
-  
-  def event_parse string, opts = {}, &block
-    parser       = opts.delete(:parser) || (self == Eventual ? DateTime : self)
-    use_trailing = opts.delete(:use_trailing)
-    string       = string.gsub('miercoles', 'miércoles').gsub('sabado', 'sábado').gsub(/'/, '').gsub(/(\s)+/, '\1')
-    results      = []
-    scanner      = StringScanner.new string
-    
-    map_months = lambda{ |months| months.scan(/#{ MESES.compact.join('|') }/).map{ |m| MESES.index(m.downcase) } }
-    make_range = lambda{ |first, last, min, max| first > last ? (first..max).map + (min..last).map : (first..last).map }
-    
-    extract_wdays  = lambda do |wdays|
-      wdays_array  = wdays ? wdays.scan( /#{ WDAY_LIST.join('|') }/ ).map{ |d| WDAY_LIST.index d.downcase } : []
-      next wdays_array unless rango_de(DIAS_DE_LA_SEMANA) === wdays
-      make_range[wdays_array.first, wdays_array.last, 0, 6]
-    end
-    
-    until scanner.eos?
-      case match = scanner.scan(/.*?(?:#{ DAY_LIST }|#{ DAY_PERIOD }|#{ WHOLE_MONTH })/m)
-        
-      when DAY_PERIOD
-        wdays, first_wday, first_day, first_month, first_year, last_wday, last_day, last_month, last_year, times = $1, $2, $3, $4, $5, $6, $7, $8, $9, $10
-       
-        wdays_array   = extract_wdays[wdays]
-        last_year   ||= string.match(/\d{4}/) ? $& : Date.today.year
-        first_year  ||= last_year
-        first_month ||= last_month
-        last_month    = MESES.index last_month.downcase
-        first_month   = MESES.index first_month.downcase
-        
-        make_days     = lambda do |hour, minute|
-          first       = make_day parser, first_year, first_month, first_day, hour, minute
-          last        = make_day parser, last_year,  last_month,  last_day,  hour, minute
-          
-          [first, last].zip([first_wday, last_wday]).each do |day, wday|
-            raise WdayMatchError.new("El día #{ day } cae en #{ DIAS_DE_LA_SEMANA[day.wday] }, no en #{ wday.downcase }") unless day.wday == WDAY_LIST.index(wday.downcase) if wday
-          end
-          
-          next (first..last).map if wdays_array.empty?
-          (first..last).select{ |day| wdays_array.include? day.wday }
-        end
-      
-      when DAY_LIST
-        daynums, month, year, times = $1, MESES.index($2.downcase), $3, $4
-
-        year    ||= string.match(/\d{4}/) ? $& : Date.today.year
-        make_days = lambda do |hour, minute|
-          daynums.scan(/(?:(#{ DIAS_DE_LA_SEMANA.join('|') }) )?(\d{1,2})/).collect do |wday, daynum|
-            day   = make_day(parser, year, month, daynum, hour, minute)
-            raise WdayMatchError.new("El día #{ day } cae en #{ DIAS_DE_LA_SEMANA[day.wday] }, no en #{ wday.downcase }") unless day.wday == WDAY_LIST.index(wday.downcase) if wday
-            day
-          end
-        end
-
-      when WHOLE_MONTH
-        wdays, month_range_start, starting_year, month_range_end, ending_year, months, year, times = $1, $2, $3, $4, $5, $6, $7, $8
-        wdays_array = extract_wdays[wdays]
-
-        month_array =
-        if month_range_start
-          ending_year ||= Date.today.year
-          first = Date.civil( (starting_year || ending_year).to_i, MESES.index(month_range_start.downcase) )
-          last  = Date.civil ending_year.to_i, MESES.index(month_range_end.downcase)
-          (first..last)
-        else  
-          year ||= Date.today.year
-          months.scan(/#{ MESES.compact.join('|') }/).map do |m|
-            Date.civil year.to_i, MESES.index(m.downcase)
-          end
-        end
-
-        make_days = lambda do |hour, minute|
-          months  = month_array.map do |date|
-            first = make_day(parser, date.year, date.month, 1, hour, minute)
-            last  = (first >> 1) - 1
-            next (first..last).map if wdays_array.empty?
-            (first..last).select{ |day| wdays_array.include? day.wday }
-          end.flatten
-        end
-        
-      else
-        break
-      end
-      
-      extra = scanner.scan(/.*?(?=#{ DAY_LIST }|#{ DAY_PERIOD }|\z)/m).to_s.chomp
-      extra.gsub!(/^(,|\n|\.)/, '')
-      
-      days  =
-      if times
-        times.scan( /(\d{2}):(\d{2})/ ).map{ |hour, minute| make_days.call hour, minute }.flatten
-      else
-        make_days.call nil, nil 
-      end
-      
-      days.each { |day| day.instance_variable_set('@extra', extra) } 
-      results += days
-    end
-    
-    raise ArgumentError.new( 'El formato de las fechas parece ser incorrecto' ) if results.empty?
-    results.uniq!
-    results.sort!
-    
-    use_trailing ? results.map!{ |day| yield day, day.instance_variable_get('@extra') } : results.map!{ |day| yield day } if block_given?
-    results
-  end
-
-  protected
-  def make_day *args 
-    maker = args.shift
-    if maker == Date
-      maker.civil *args.compact.collect{ |a| a.to_i }[0...4]
-    else
-      maker.civil *args.compact.collect{ |a| a.to_i }
-    end
-  end
-end
+require "#{ File.dirname __FILE__ }/eventual/syntax_nodes"
 
+autoload :EsDatesParser, 'eventual/es'

data/spec/es_eventual_spec.rb

@@ -1,222 +1,435 @@
-require File.expand_path( File.dirname(__FILE__) + '/spec_helper' )
+require "#{File.dirname __FILE__}/spec_helper"
+require 'eventual'
 
-describe 'event parsing' do
+describe Eventual, 'Es' do
+  before do
+    @parser = EsDatesParser.new
+    Date.stub!(:today).and_return Date.civil(2010)
+  end
 
-  describe 'lista de número dia' do
-    it "should event_parse one day" do
-      Eventual.event_parse( '1 de enero del 2009' ).should map_times( '2009-1-1' )
-    end
-  
-    it "should event_parse several days" do
-      Eventual.event_parse( '1, 2 y 3 de enero' ).should map_times( "2009-1-1", "2009-1-2", "2009-1-3" )
-    end
-  
-    it "should match several days with year" do
-      Eventual.event_parse( '1, 2 y 3 de enero del 2010' ).should map_times( "2010-1-1", "2010-1-2", "2010-1-3" )
-    end
-  
-    it "should event_parse one day with one time" do
-      Eventual.event_parse( '1 de enero del 2009 a las 16:00 horas' ).should map_times( '2009-1-1T16:00' )
-    end
-    
-    it "should parse one day with wday" do
-      Eventual.event_parse( 'viernes 1 de enero del 2010' ).should map_times( '2010-1-1' )
+  shared_examples_for 'correctly parses' do
+    it { @result.should_not be_nil }
+    it { @result.to_a.size.should == @dates.map.size }
+    it { @result.should map_dates *@dates }
+    it { @dates.map{ |date| @result.should include(date) } }
+    it { @result.should_not include(@dates.first - 1) }
+    it { @result.should_not include(@dates.last + 1) }
+    it { @dates.select{ |d| @result.include? d }.map{ |d| d.to_s  }.should == @dates.map{ |r| r.to_s  } }
+  end
+
+  describe 'month' do
+    describe "month without year parsing 'marzo'" do
+      before do
+        @result = @parser.parse 'marzo'
+        @dates  = (Date.parse('2010-3-1')..Date.parse('2010-3-31')).map
+      end
+      it_should_behave_like 'correctly parses'
     end
-    
-    it "should parse list with wday" do
-      Eventual.event_parse( 'viernes 1, sábado 2, domingo 3 y lunes 4 de enero del 2010' ).should map_times( '2010-1-1', '2010-1-2', '2010-1-3', '2010-1-4' )
+
+    describe 'month with year' do
+      describe "parsing 'marzo de 2009'" do
+        before do
+          @result = @parser.parse "marzo de 2009"
+          @dates  = (Date.parse('2009-3-1')..Date.parse('2009-3-31')).map
+        end  
+        it_should_behave_like 'correctly parses'
+      end
+
+      describe "parsing 'marzo del 2009'" do
+        before do
+          @result = @parser.parse "marzo del 2009"
+          @dates  = (Date.parse('2009-3-1')..Date.parse('2009-3-31')).map
+        end  
+        it_should_behave_like 'correctly parses'
+      end
+
+      describe "parsing 'marzo 2009'" do
+        before do
+          @result = @parser.parse "marzo 2009"
+          @dates  = (Date.parse('2009-3-1')..Date.parse('2009-3-31')).map
+        end  
+        it_should_behave_like 'correctly parses'
+      end
+
+      describe "parsing 'marzo, 2009'" do
+        before do
+          @result = @parser.parse "marzo, 2009"
+          @dates  = (Date.parse('2009-3-1')..Date.parse('2009-3-31')).map
+        end  
+        it_should_behave_like 'correctly parses'
+      end
+
+      describe "parsing 'marzo '09'" do
+        before do
+          @result = @parser.parse "marzo '09"
+          @dates  = (Date.parse('2009-3-1')..Date.parse('2009-3-31')).map
+        end  
+        it_should_behave_like 'correctly parses'
+      end
     end
-    
-    it "should blow if wday doesn't correspond" do
-      lambda{ Eventual.event_parse('sábado 1 de enero del 2010') }.should raise_error(Eventual::WdayMatchError)
+
+    describe 'month with wdays' do
+      before do
+        @dates = (Date.parse('2010-3-1')..Date.parse('2010-3-31')).reject{ |day| not [1,2].include?(day.wday) }
+      end
+
+      describe "parsing 'lunes y martes marzo del 2010'" do
+        before { @result = @parser.parse "lunes y martes marzo del 2010" }
+        it_should_behave_like 'correctly parses'
+      end
+
+      describe "parsing 'lunes y martes de marzo del 2010'" do
+        before { @result = @parser.parse "lunes y martes de marzo del 2010" }
+        it_should_behave_like 'correctly parses'
+      end
+
+      describe "parsing 'lunes y martes durante marzo del 2010'" do
+        before { @result = @parser.parse "lunes y martes durante marzo del 2010" }
+        it_should_behave_like 'correctly parses'
+      end
+
+      describe "parsing 'lunes y martes durante todo marzo del 2010'" do
+        before { @result = @parser.parse "lunes y martes durante todo marzo del 2010" }
+        it_should_behave_like 'correctly parses'
+      end
+
+      describe "parsing 'lunes y martes, marzo del 2010'" do
+        before { @result = @parser.parse "lunes y martes, marzo del 2010" }
+        it_should_behave_like 'correctly parses'
+      end
     end
+
   end
 
-  describe 'lista de rango de número de día' do
-    it "should event_parse a period" do
-      Eventual.event_parse( 'del 1 al 3 de enero' ).should map_times( '2009-1-1', '2009-1-2', '2009-1-3' )
-    end
-  
-    it "should event_parse a period with year" do
-      Eventual.event_parse( 'del 1 al 3 de enero 2010' ).should map_times( '2010-1-1', '2010-1-2', '2010-1-3' )
+  describe 'day numbers' do
+    describe 'single date' do
+      before do
+        @dates = [Date.civil 2010, 3, 21]
+      end
+
+      describe "should single day number for '21 de marzo'" do
+        before { @result = @parser.parse("21 de marzo") }
+        it_should_behave_like 'correctly parses'
+      end
+
+      describe "parsing '21 marzo'" do
+        before { @result = @parser.parse("21 marzo") }
+        it_should_behave_like 'correctly parses'
+      end
+
+      # describe "parsing 'marzo 21'" do
+      #   before { @result = @parser.parse("21 marzo") }
+      #   it_should_behave_like 'correctly parses'
+      # end
+
+      describe 'date with wday' do
+        describe "parsing 'domingo 21 de marzo'" do
+          before { @result = @parser.parse("domingo 21 de marzo") }
+          it_should_behave_like 'correctly parses'
+        end
+
+        it "should raise WdayMatchError if weekday doesn't correspond to date" do
+          lambda { @parser.parse("lunes 21 de marzo").map }.should raise_error(Eventual::WdayMatchError)
+        end
+      end
     end
-  
-    it "should event_parse a period with time" do
-      Eventual.event_parse( 'miércoles del 1 al 3 de junio' ).should map_times( '2009-6-3' )
+
+    describe 'day list' do
+      before do
+        @dates = (1..3).map{ |i| Date.civil( 2010, 3, i) }
+      end
+
+      describe "day list for '1, 2 y 3 de marzo'" do
+        before { @result = @parser.parse("1, 2 y 3 marzo") }
+        it_should_behave_like 'correctly parses'
+      end
+
+      describe "day list for '1, 2 y 3 marzo'" do
+        before { @result = @parser.parse("1, 2 y 3 de marzo") }
+        it_should_behave_like 'correctly parses'
+      end
+
+      describe "day list with weekday 'lunes 1, martes 2 y miercoles 3 de marzo'" do
+        before { @result = @parser.parse("lunes 1, martes 2 y miercoles 3 de marzo") }
+        it_should_behave_like 'correctly parses'
+      end
+
+      it "should raise WdayMatchError if weekday doesn't correspond to date" do
+        lambda { @parser.parse("lunes 2, martes 2 y jueves 3 de marzo").map }.should raise_error(Eventual::WdayMatchError)
+      end
     end
-  
-    it "should event_parse a period with time" do
-      Eventual.event_parse( 'miércoles del 1 al 3 de junio a las 16:00 horas' ).should map_times( '2009-6-3T16:00' )
+  end
+
+  describe 'day range' do
+    describe 'period in same month' do
+      before do
+        @dates = (1..3).map{ |i| Date.civil( 2010, 3, i) }
+      end
+
+      describe "day list for '1 al 3 de marzo" do
+        before { @result = @parser.parse("1 al 3 de marzo del '10") }
+        it_should_behave_like 'correctly parses'
+      end
+
+      describe "day list for '1 al 3, marzo" do
+        before { @result = @parser.parse("1 al 3, marzo del '10") }
+        it_should_behave_like 'correctly parses'
+      end
+
+      describe "day list for 'del 1 al 3 de marzo" do
+        before { @result = @parser.parse("del 1 al 3 de marzo del '10") }
+        it_should_behave_like 'correctly parses'
+      end
+
+      describe "day list for 'del 1 al 3, marzo" do
+        before { @result = @parser.parse("del 1 al 3, marzo del '10") }
+        it_should_behave_like 'correctly parses'
+      end
     end
-  
-    it "should event_parse one day with several times" do
-      Eventual.event_parse( '1 de enero del 2009 a las 16:00 y 17:00' ).should map_times( '2009-1-1T16:00', '2009-1-1T:17:00' )
+
+    describe "spanning diferent months '24 de febrero al 3 de marzo del 2010" do
+      before do
+        @result = @parser.parse "24 de febrero al 3 de marzo del 2010"
+        @dates  = (Date.parse('2010-2-24')..Date.parse('2010-3-3'))
+      end
+      it_should_behave_like 'correctly parses'
     end
-  
-    it "should event_parse period spanning more than one month" do
-      Eventual.event_parse( 'del 29 de enero al 3 de febrero' ).should map_times( '2009-1-29', '2009-1-30', '2009-1-31', '2009-2-1', '2009-2-2', '2009-2-3' )
+
+    describe "spanning diferent years '24 de diciembre del 2009 al 3 de enero del 2010" do
+      before do 
+        @result = @parser.parse("24 de diciembre del 2009 al 3 de enero del 2010")
+        @dates  = (Date.parse('2009-12-24')..Date.parse('2010-1-3'))
+      end
+      it_should_behave_like 'correctly parses'
     end
   
-    it "should parse period spanning across year" do
-      Eventual.event_parse( 'del 28 de diciembre del 2009 al 2 de enero del 2010').should map_times( '2009-12-28', '2009-12-29', '2009-12-30', '2009-12-31', '2010-1-1', '2010-1-2')
-    end
-    
-    it "should parse range with wday" do
-      Eventual.event_parse( 'viernes 1 al domingo 3 de enero del 2010' ).should map_times( '2010-1-1', '2010-1-2', '2010-1-3' )
-    end
-    
-    it "should blow if wday doesn't correspond" do
-      lambda{ Eventual.event_parse('viernes 2 a domingo 4 de enero del 2010') }.should raise_error(Eventual::WdayMatchError)
-    end
+    describe 'period spanning two dates' do
+      before do
+        @dates = (Date.parse('2008-10-1')..DateTime.parse('2008-12-2'))
+      end
+      
+      describe "1 de octubre a 2 de diciembre del 2008" do
+        before { @result = @parser.parse "1 de octubre a 2 de diciembre del 2008" }
+        it_should_behave_like 'correctly parses'
+      end
     
-    describe 'restringido por dia de la semana' do
-      it "should parse all tuesdays and thursdays of the year" do
-        e = Eventual.event_parse( 'martes y jueves del 1 de enero al 31 de diciembre del 2008')
-        r = ( DateTime.parse('2008-1-1')..DateTime.parse('2008-12-31') ).reject{ |day| not [2,4].include?(day.wday) }
-        e.should map_times( *r )
+      describe "1 de octubre al 2 de diciembre del 2008" do
+        before { @result = @parser.parse "1 de octubre al 2 de diciembre del 2008" }
+        it_should_behave_like 'correctly parses'
       end
 
-      it "should parse all tuesdays and thursdays of the year with time" do
-        e = Eventual.event_parse( 'martes y jueves del 1 de enero al 31 de diciembre del 2008 a las 16:00')
-        r = ( DateTime.parse('2008-1-1T16:00')..DateTime.parse('2008-12-31T16:00') ).reject{ |day| not [2,4].include?(day.wday) }
-        e.should map_times( *r )
+      describe "del miercoles 1 de octubre al martes 2 de diciembre del 2008" do
+        before { @result = @parser.parse "del miercoles 1 de octubre al martes 2 de diciembre del 2008" }
+        it_should_behave_like 'correctly parses'
       end
+    end
 
-      it "should parse all saturdays and sundays of the year with time" do
-        e = Eventual.event_parse( 'sábado y domingo del 1 de enero al 31 de diciembre del 2008 a las 16:00')
-        r = ( DateTime.parse('2008-1-1T16:00')..DateTime.parse('2008-12-31T16:00') ).reject{ |day| not [0,6].include?(day.wday) }
-        e.should map_times( *r )
+    describe "lunes y martes del 1 de octubre al 2 de diciembre del 2008" do
+      before do 
+        @result = @parser.parse "lunes y martes del 1 de octubre al 2 de diciembre del 2008"
+        @dates  = (Date.parse('2008-10-1')..DateTime.parse('2008-12-2')).reject{ |day| not [1,2].include?(day.wday) }
+      end
+      it_should_behave_like 'correctly parses'
+    end
+  
+    describe 'with weekday constrain' do
+      describe "wdays for 'lunes y martes del 1 al 22 de marzo del '10" do
+        before do 
+          @result = @parser.parse "lunes y martes del 1 al 22 de marzo del '10"
+          @dates  = (Date.parse('2010-3-1')..Date.parse('2010-3-22')).reject{ |day| not [1,2].include?(day.wday) }
+        end
+        it_should_behave_like 'correctly parses'
       end
 
-      it "should parse all pluralized saturdays and sundays of the year with time" do
-        e = Eventual.event_parse( 'sábados y domingos del 1 de enero al 31 de diciembre del 2008 a las 16:00')
-        r = ( DateTime.parse('2008-1-1T16:00')..DateTime.parse('2008-12-31T16:00') ).reject{ |day| not [0,6].include?(day.wday) }
-        e.should map_times( *r )
+      describe "wdays for 'fines de semana del 1 al 22 de marzo del '10" do
+        before do
+          @result = @parser.parse "fines de semana del 1 al 22 de marzo del '10"
+          @dates  = (Date.parse('2010-3-1')..Date.parse('2010-3-22')).map.reject{ |day| not [6,0].include?(day.wday) }
+        end
+        it_should_behave_like 'correctly parses'
       end
 
-      it "should parse week day period" do
-        e = Eventual.event_parse( 'lunes a viernes del 1 de enero al 31 de diciembre del 2008 a las 16:00')
-        r = ( DateTime.parse('2008-1-1T16:00')..DateTime.parse('2008-12-31T16:00') ).reject{ |day| not (1..5).map.include?(day.wday) }
-        e.should map_times( *r )
+      describe "wdays for 'entre semana del 1 al 22 de marzo del '10" do
+        before do 
+          @result = @parser.parse("entre semana del 1 al 22 de marzo del '10")
+          @dates  = (Date.parse('2010-3-1')..Date.parse('2010-3-22')).map.reject{ |day| not (1..5).map.include?(day.wday) }
+        end
+        it_should_behave_like 'correctly parses'
       end
+    
+      describe 'sugar for wday constrain' do
+        before do
+          @dates = (Date.parse('2010-3-1')..Date.parse('2010-3-22')).reject{ |day| not [1,2].include?(day.wday) }
+        end
+
+        describe "wdays for 'lunes y martes del 1 al 22 de marzo del '10" do
+          before { @result = @parser.parse("lunes y martes del 1 al 22 de marzo del '10") }
+          it_should_behave_like 'correctly parses'
+        end
 
-      it "should parse week day period across week" do
-        e = Eventual.event_parse( 'viernes a lunes del 1 de enero al 31 de diciembre del 2008 a las 16:00')
-        r = ( DateTime.parse('2008-1-1T16:00')..DateTime.parse('2008-12-31T16:00') ).reject{ |day| not [5,6,0,1].map.include?(day.wday) }
-        e.should map_times( *r )
+        describe "wdays for 'todos los lunes y martes del 1 al 22 de marzo del '10" do
+          before { @result = @parser.parse("todos los lunes y martes del 1 al 22 de marzo del '10") }
+          it_should_behave_like 'correctly parses'
+        end
+
+        describe "wdays for 'los lunes y martes del 1 al 22 de marzo del '10" do
+          before { @result = @parser.parse("los lunes y martes del 1 al 22 de marzo del '10") }
+          it_should_behave_like 'correctly parses'
+        end
+        
+        describe "wdays for 'los lunes y los martes del 1 al 22 de marzo del '10" do
+          before { @result = @parser.parse("los lunes y los martes del 1 al 22 de marzo del '10") }
+          it_should_behave_like 'correctly parses'
+        end
       end
     end
   end
-  
-  describe 'Meses completos' do
-    it "should parse a single month" do
-      ['diciembre del 2008', 'durante diciembre del 2008', 'durante todo diciembre del 2008'].each do |e|
-        Eventual.event_parse(e).should map_times( *(DateTime.parse('2008-12-1T00:00')..DateTime.parse('2008-12-31T00:00')).map )
+
+  describe 'month range' do
+    describe 'octubre a diciembre del 2008' do
+      before do 
+        @result = @parser.parse('octubre a diciembre del 2008')
+        @dates  = (Date.parse('2008-10-1')..DateTime.parse('2008-12-31')).map
       end
+      it_should_behave_like 'correctly parses'
     end
-  
-    it "should parse two full months" do
-      ['noviembre y diciembre del 2008', 'durante noviembre y diciembre del 2008', 'durante todo noviembre y diciembre del 2008'].each do |e|
-        Eventual.event_parse(e).should map_times( *(DateTime.parse('2008-11-1T00:00')..DateTime.parse('2008-12-31T00:00')).map )
+    
+    
+    describe 'lunes y martes de octubre del 2007 a diciembre del 2008' do
+      before do 
+        @result = @parser.parse('lunes y martes de octubre del 2007 a diciembre del 2008')
+        @dates  = (Date.parse('2007-10-1')..DateTime.parse('2008-12-31')).reject{ |day| not [1,2].include?(day.wday) }
       end
+      it_should_behave_like 'correctly parses'
     end
-  
-    it "should parse severals full months" do
-      ['octubre, noviembre y diciembre del 2008', 'durante octubre, noviembre y diciembre del 2008', 'durante todo octubre, noviembre y diciembre del 2008'].each do |e|
-        Eventual.event_parse(e).should map_times( *(DateTime.parse('2008-10-1T00:00')..DateTime.parse('2008-12-31T00:00')).map )
-      end
+  end
+
+  describe 'compound dates giving year at the end' do
+    before do
+      @result = @parser.parse "1 de enero y lunes y martes del 1 de octubre al 2 de diciembre del 2008"
+      @dates  = [Date.parse('2008-1-1')] + (Date.parse('2008-10-1')..Date.parse('2008-12-2')).reject{ |day| not [1,2].include?(day.wday) }
     end
+    it_should_behave_like 'correctly parses'
+  end
   
-    it "should parse a full month with time" do
-      Eventual.event_parse('diciembre del 2008 a las 16:00 horas').should map_times( *(DateTime.parse('2008-12-1T16:00')..DateTime.parse('2008-12-31T16:00')).map )
+  describe 'compound dates in different lines' do
+    before do
+      @result = @parser.parse "1 de enero\nlunes y martes del 1 de octubre al 2 de diciembre del 2008"
+      @dates  = [Date.parse('2008-1-1')] + (Date.parse('2008-10-1')..Date.parse('2008-12-2')).reject{ |day| not [1,2].include?(day.wday) }
     end
+    it_should_behave_like 'correctly parses'
+  end
   
-    it "should parse a full month with time with days" do
-      Eventual.event_parse('domingos de diciembre del 2008').should map_times( *(DateTime.parse('2008-12-1T00:00')..DateTime.parse('2008-12-31T00:00')).reject{ |day| not [0].include?(day.wday) } )
+  describe 'with time constrain' do
+    shared_examples_for 'outputs DateTime' do
+      it "should all be DateTime" do
+        @result.map{ |d| d.should be_a(DateTime) }
+      end
     end
     
-    it "should parse a full month with time with days and sugar" do
-      ['todos los domingos de diciembre del 2008', 'los domingos durante todo diciembre del 2008'].each do |e|
-        Eventual.event_parse(e).should map_times( *(DateTime.parse('2008-12-1T00:00')..DateTime.parse('2008-12-31T00:00')).reject{ |day| not [0].include?(day.wday) } )
+    describe 'single day with time' do
+      before do
+        @result = @parser.parse('1 de enero del 2010 a las 15:00')
+        @dates  = [DateTime.civil 2010, 1, 1, 15]
       end
+      it_should_behave_like 'correctly parses'
+      it_should_behave_like 'outputs DateTime'
     end
     
-    it "should parse a full month with time with days" do
-      ['sábados y domingos de diciembre del 2008', 'todos los sábados y domingos de diciembre del 2008', 'sábados y domingos durante todo diciembre del 2008'].each do |e|
-        Eventual.event_parse(e).should map_times( *(DateTime.parse('2008-12-1T00:00')..DateTime.parse('2008-12-31T00:00')).reject{ |day| not [0, 6].include?(day.wday) } )
+    describe 'single time with no sugar for month range' do
+      before do
+        @result = @parser.parse('lunes y martes de diciembre del 2010 a las 15:00')
+        @dates  = (DateTime.parse('2010-12-1T15:00')..DateTime.parse('2010-12-31T15:00')).reject{ |day| not [1,2].include?(day.wday) }
       end
+      it_should_behave_like 'correctly parses'
+      it_should_behave_like 'outputs DateTime'
     end
     
-    it "should parse a full month with time with days" do
-      ['todos los sábados a lunes de diciembre del 2008', 'sábado a lunes de diciembre del 2008', 'sábados a lunes durante todo diciembre del 2008'].each do |e|
-        Eventual.event_parse(e).should map_times( *(DateTime.parse('2008-12-1T00:00')..DateTime.parse('2008-12-31T00:00')).reject{ |day| not [0, 1, 6].include?(day.wday) } )
+    describe 'single time with sugar 1 for month range' do
+      before do
+        @result = @parser.parse('lunes y martes de diciembre a las 15:00 hrs.')
+        @dates  = (DateTime.parse('2010-12-1T15:00')..DateTime.parse('2010-12-31T15:00')).reject{ |day| not [1,2].include?(day.wday) }
       end
+      it_should_behave_like 'correctly parses'
+      it_should_behave_like 'outputs DateTime'
     end
     
-    it "should parse without year" do
-      Eventual.event_parse('sábados de diciembre').should map_times( *(DateTime.parse("#{ y = Date.today.year }-12-1T00:00")..DateTime.parse("#{ y }-12-31T00:00")).reject{ |day| not [6].include?(day.wday) } )
+    describe 'single time with sugar 2 for month range' do
+      before do
+        @result = @parser.parse('lunes y martes de diciembre a las 15:00hrs')
+        @dates  = (DateTime.parse('2010-12-1T15:00')..DateTime.parse('2010-12-31T15:00')).reject{ |day| not [1,2].include?(day.wday) }
+      end
+      it_should_behave_like 'correctly parses'
+      it_should_behave_like 'outputs DateTime'
     end
     
-    it "should parse month range" do
-      Eventual.event_parse('octubre a diciembre del 2008').should map_times( *(DateTime.parse('2008-10-1T00:00')..DateTime.parse('2008-12-31T00:00')).map )
+    describe 'single time with sugar 3 for month range' do
+      before do
+        @result = @parser.parse('lunes y martes de diciembre a las 15 horas')
+        @dates  = (DateTime.parse('2010-12-1T15:00')..DateTime.parse('2010-12-31T15:00')).reject{ |day| not [1,2].include?(day.wday) }
+      end
+      it_should_behave_like 'correctly parses'
+      it_should_behave_like 'outputs DateTime'
     end
     
-    it "should parse month range" do
-      Eventual.event_parse('diciembre del 2008 a enero del 2009').should map_times( *(DateTime.parse('2008-12-1T00:00')..DateTime.parse('2009-1-31T00:00')).map )
-    end
-  end
-
-  it "should event_parse a period with block" do
-    Eventual.event_parse( 'del 5 al 7 de junio 2009' ){ |d| Eventual::WDAY_LIST[ d.wday ] }.should == ['viernes', 'sábado', 'domingo']
-  end
-  
-  it "should parse several expressions" do
-    Eventual.event_parse( '1 de enero y 2 de febrero del 2008' ).should map_times( '2008-1-1', '2008-2-2' )
-  end
-  
-  it "should event_parse period spanning more than one month" do
-    Eventual.event_parse( '1 de enero, del 29 de enero al 3 de febrero y 2 de febrero del 2008' ).should map_times( '2008-1-1', '2008-1-29', '2008-1-30', '2008-1-31', '2008-2-1', '2008-2-2', '2008-2-3' )
-  end
-  
-  it "should event_parse a several dates separated by \\n" do |d, extra|
-    Eventual.event_parse( "1 de enero del 2009\n2 de enero del 2009" ) do |d|
-      d.to_s
-    end.should == ["2009-01-01T00:00:00+00:00", "2009-01-02T00:00:00+00:00"]
-  end
-  
-  describe 'With extra data' do
-    it "should event_parse one day with one time" do
-      Eventual.event_parse( "1 de enero del 2009 a las 16:00 horas\nSede:Áreas verdes\nCupo: limitado", :use_trailing => true ) do |day, extra|
-        day.to_s.should == "2009-01-01T16:00:00+00:00"
-        extra.should == "Sede:Áreas verdes\nCupo: limitado"
+    describe 'two times for month range' do
+      before do
+        @result = @parser.parse('lunes y martes de diciembre a las 16:00 y 15:00 horas')
+        @dates  = ((DateTime.parse('2010-12-1T15:00')..DateTime.parse('2010-12-31T15:00')).map + (DateTime.parse('2010-12-1T16:00')..DateTime.parse('2010-12-31T16:00')).map).reject{ |day| not [1,2].include?(day.wday) }
+      end
+      it_should_behave_like 'correctly parses'
+      it_should_behave_like 'outputs DateTime'
+      
+      it "should not include other time" do
+        @result.should_not include(DateTime.parse('2010-12-06T14:00'))
       end
     end
-
-    it "should event_parse a period with block" do
-      Eventual.event_parse( "del 5 al 7 de junio 2009\nSede:El tercer lugar\nCupo: limitado", :use_trailing => true ) do |d, extra|
-        extra.should == "Sede:El tercer lugar\nCupo: limitado"
-        Eventual::WDAY_LIST[ d.wday ]
-      end.should == ['viernes', 'sábado', 'domingo']
+    
+    describe 'range with time as 12 hours am' do
+      before do
+        @result = @parser.parse('lunes y martes de diciembre a las 3 am')
+        @dates  = ((DateTime.parse('2010-12-1T03:00')..DateTime.parse('2010-12-31T03:00')).map).reject{ |day| not [1,2].include?(day.wday) }
+      end
+      it_should_behave_like 'correctly parses'
+      it_should_behave_like 'outputs DateTime'
+      
+      it "should not include other time" do
+        @result.should_not include(DateTime.parse('2010-12-06T14:00'))
+      end
     end
     
-    it "should event_parse a several dates" do
-      Eventual.event_parse( "1 de enero del 2009\nSede:El tercer lugar\nCupo: limitado\n2 de enero del 2009\nSede:El tercer lugar\nCupo: limitado", :use_trailing => true ) do |d, extra|
-        extra.should == "Sede:El tercer lugar\nCupo: limitado"
-        d.to_s
-      end.should == ["2009-01-01T00:00:00+00:00", "2009-01-02T00:00:00+00:00"]
+    describe 'range with time as 12 hours pm' do
+      before do
+        @result = @parser.parse('lunes y martes de diciembre a las 3:00 pm')
+        @dates  = ((DateTime.parse('2010-12-1T15:00')..DateTime.parse('2010-12-31T15:00')).map).reject{ |day| not [1,2].include?(day.wday) }
+      end
+      it_should_behave_like 'correctly parses'
+      it_should_behave_like 'outputs DateTime'
+      
+      it "should not include other time" do
+        @result.should_not include(DateTime.parse('2010-12-06T14:00'))
+      end
     end
+  end
   
-    it "should event_parse a several dates" do
-      Eventual.event_parse( "1 de enero del 2009\nSede 1\n\n2 de enero del 2009\nSede 2", :use_trailing => true ) do |d, extra|
-        [d.to_s, extra]
-      end.should == [["2009-01-01T00:00:00+00:00", "Sede 1"], ["2009-01-02T00:00:00+00:00", "Sede 2"]]
+  describe 'Marshal dump' do
+    describe "month without year parsing 'marzo'" do
+      before do
+        @result = Marshal.load Marshal.dump(@parser.parse('marzo')).gsub('NaturalDates::', 'NaturalDates::Eventual::Es::')
+        @dates  = (Date.parse('2010-3-1')..Date.parse('2010-3-31')).map
+      end
+      it_should_behave_like 'correctly parses'
     end
   end
   
-  describe 'Case sensitivity' do
-    it "should ignore case" do
-      Eventual.event_parse( 'DeL 1 al 3 de ENeRO' ).should map_times( '2009-1-1', '2009-1-2', '2009-1-3' )
+  describe 'Default year' do
+    describe "month without year parsing 'marzo'" do
+      before do
+        @result      = @parser.parse('marzo')
+        @result.year = 2007
+        @dates       = (Date.parse('2007-3-1')..Date.parse('2007-3-31')).map
+      end
+      it_should_behave_like 'correctly parses'
     end
   end
 end
-