pangel-chronic 0.3.0.3 → 0.3.10

data/lib/chronic/repeaters/repeater_weekday.rb

@@ -1,77 +1,77 @@
 class Chronic::RepeaterWeekday < Chronic::Repeater #:nodoc:
-	WEEK_WEEKDAYS = 5
-	DAY_SECONDS = 86400 # (24 * 60 * 60)
-
-	def initialize(type)
-		super
-		@current_weekday_start = nil
-	end
-
-	def next(pointer)
-		super
-
-		direction = pointer == :future ? 1 : -1
-
-		if !@current_weekday_start
-			@current_weekday_start = Time.construct(@now.year, @now.month, @now.day)
-			@current_weekday_start += direction * DAY_SECONDS
-
-			until is_weekday?(@current_weekday_start.wday)
-				@current_weekday_start += direction * DAY_SECONDS
-			end
-		else
-			loop do
-				@current_weekday_start += direction * DAY_SECONDS
-				break if is_weekday?(@current_weekday_start.wday)
-			end
-		end
-
-		Chronic::Span.new(@current_weekday_start, @current_weekday_start + DAY_SECONDS)
-	end
-
-	def this(pointer = :future)
-		super
-
-		case pointer
-		when :past
-			self.next(:past)
-		when :future, :none
-			self.next(:future)
-		end
-	end
-
-	def offset(span, amount, pointer)
-		direction = pointer == :future ? 1 : -1
-
-		num_weekdays_passed = 0; offset = 0
-		until num_weekdays_passed == amount
-			offset += direction * DAY_SECONDS
-			num_weekdays_passed += 1 if is_weekday?((span.begin+offset).wday)
-		end
-
-		span + offset
-	end
-
-	def width
-		DAY_SECONDS
-	end
-
-	def to_s
-		super << '-weekday'
-	end
-
-	private
-
-	def is_weekend?(day)
-		day == symbol_to_number(:saturday) || day == symbol_to_number(:sunday)
-	end
-
-	def is_weekday?(day)
-		!is_weekend?(day)
-	end
-
-	def symbol_to_number(sym)
-		lookup = {:sunday => 0, :monday => 1, :tuesday => 2, :wednesday => 3, :thursday => 4, :friday => 5, :saturday => 6}
-		lookup[sym] || raise("Invalid symbol specified")
-	end
-end
+  WEEK_WEEKDAYS = 5
+  DAY_SECONDS = 86400 # (24 * 60 * 60)
+  
+  def initialize(type)
+    super
+    @current_weekday_start = nil
+  end
+  
+  def next(pointer)
+    super
+    
+    direction = pointer == :future ? 1 : -1
+    
+    if !@current_weekday_start
+      @current_weekday_start = Time.construct(@now.year, @now.month, @now.day)
+      @current_weekday_start += direction * DAY_SECONDS
+      
+      until is_weekday?(@current_weekday_start.wday)
+        @current_weekday_start += direction * DAY_SECONDS
+      end
+    else
+      loop do
+        @current_weekday_start += direction * DAY_SECONDS
+        break if is_weekday?(@current_weekday_start.wday)
+      end
+    end
+
+    Chronic::Span.new(@current_weekday_start, @current_weekday_start + DAY_SECONDS)
+  end
+  
+  def this(pointer = :future)
+    super
+    
+    case pointer
+    when :past
+      self.next(:past)
+    when :future, :none
+      self.next(:future)
+    end
+  end
+
+  def offset(span, amount, pointer)
+    direction = pointer == :future ? 1 : -1
+    
+    num_weekdays_passed = 0; offset = 0
+    until num_weekdays_passed == amount
+      offset += direction * DAY_SECONDS
+      num_weekdays_passed += 1 if is_weekday?((span.begin+offset).wday)
+    end
+    
+    span + offset
+  end
+  
+  def width
+    DAY_SECONDS
+  end
+  
+  def to_s
+    super << '-weekday'
+  end
+  
+  private
+  
+  def is_weekend?(day)
+    day == symbol_to_number(:saturday) || day == symbol_to_number(:sunday)
+  end
+  
+  def is_weekday?(day)
+    !is_weekend?(day)
+  end
+    
+  def symbol_to_number(sym)
+    lookup = {:sunday => 0, :monday => 1, :tuesday => 2, :wednesday => 3, :thursday => 4, :friday => 5, :saturday => 6}
+    lookup[sym] || raise("Invalid symbol specified")
+  end
+end

data/lib/chronic/repeaters/repeater_weekend.rb

@@ -1,65 +1,65 @@
 class Chronic::RepeaterWeekend < Chronic::Repeater #:nodoc:
-	WEEKEND_SECONDS = 172_800 # (2 * 24 * 60 * 60)
+  WEEKEND_SECONDS = 172_800 # (2 * 24 * 60 * 60)
 
-	def initialize(type)
-		super
-		@current_week_start = nil
-	end
-
-	def next(pointer)
-		super
-
-		if !@current_week_start
-			case pointer
-			when :future
-				saturday_repeater = Chronic::RepeaterDayName.new(:saturday)
-				saturday_repeater.start = @now
-				next_saturday_span = saturday_repeater.next(:future)
-				@current_week_start = next_saturday_span.begin
-			when :past
-				saturday_repeater = Chronic::RepeaterDayName.new(:saturday)
-				saturday_repeater.start = (@now + Chronic::RepeaterDay::DAY_SECONDS)
-				last_saturday_span = saturday_repeater.next(:past)
-				@current_week_start = last_saturday_span.begin
-			end
-		else
-			direction = pointer == :future ? 1 : -1
-			@current_week_start += direction * Chronic::RepeaterWeek::WEEK_SECONDS
-		end
-
-		Chronic::Span.new(@current_week_start, @current_week_start + WEEKEND_SECONDS)
-	end
-
-	def this(pointer = :future)
-		super
-
-		case pointer
-		when :future, :none
-			saturday_repeater = Chronic::RepeaterDayName.new(:saturday)
-			saturday_repeater.start = @now
-			this_saturday_span = saturday_repeater.this(:future)
-			Chronic::Span.new(this_saturday_span.begin, this_saturday_span.begin + WEEKEND_SECONDS)
-		when :past
-			saturday_repeater = Chronic::RepeaterDayName.new(:saturday)
-			saturday_repeater.start = @now
-			last_saturday_span = saturday_repeater.this(:past)
-			Chronic::Span.new(last_saturday_span.begin, last_saturday_span.begin + WEEKEND_SECONDS)
-		end
-	end
-
-	def offset(span, amount, pointer)
-		direction = pointer == :future ? 1 : -1
-		weekend = Chronic::RepeaterWeekend.new(:weekend)
-		weekend.start = span.begin
-		start = weekend.next(pointer).begin + (amount - 1) * direction * Chronic::RepeaterWeek::WEEK_SECONDS
-		Chronic::Span.new(start, start + (span.end - span.begin))
-	end
-
-	def width
-		WEEKEND_SECONDS
-	end
-
-	def to_s
-		super << '-weekend'
-	end
-end
+  def initialize(type)
+    super
+    @current_week_start = nil
+  end
+  
+  def next(pointer)
+    super
+    
+    if !@current_week_start
+      case pointer
+      when :future
+        saturday_repeater = Chronic::RepeaterDayName.new(:saturday)
+        saturday_repeater.start = @now
+        next_saturday_span = saturday_repeater.next(:future)
+        @current_week_start = next_saturday_span.begin
+      when :past
+        saturday_repeater = Chronic::RepeaterDayName.new(:saturday)
+        saturday_repeater.start = (@now + Chronic::RepeaterDay::DAY_SECONDS)
+        last_saturday_span = saturday_repeater.next(:past)
+        @current_week_start = last_saturday_span.begin
+      end
+    else
+      direction = pointer == :future ? 1 : -1
+      @current_week_start += direction * Chronic::RepeaterWeek::WEEK_SECONDS
+    end
+    
+    Chronic::Span.new(@current_week_start, @current_week_start + WEEKEND_SECONDS)
+  end
+  
+  def this(pointer = :future)
+    super
+    
+    case pointer
+    when :future, :none
+      saturday_repeater = Chronic::RepeaterDayName.new(:saturday)
+      saturday_repeater.start = @now
+      this_saturday_span = saturday_repeater.this(:future)
+      Chronic::Span.new(this_saturday_span.begin, this_saturday_span.begin + WEEKEND_SECONDS)
+    when :past
+      saturday_repeater = Chronic::RepeaterDayName.new(:saturday)
+      saturday_repeater.start = @now
+      last_saturday_span = saturday_repeater.this(:past)
+      Chronic::Span.new(last_saturday_span.begin, last_saturday_span.begin + WEEKEND_SECONDS)
+    end
+  end
+  
+  def offset(span, amount, pointer)
+    direction = pointer == :future ? 1 : -1
+    weekend = Chronic::RepeaterWeekend.new(:weekend)
+    weekend.start = span.begin
+    start = weekend.next(pointer).begin + (amount - 1) * direction * Chronic::RepeaterWeek::WEEK_SECONDS
+    Chronic::Span.new(start, start + (span.end - span.begin))
+  end
+  
+  def width
+    WEEKEND_SECONDS
+  end
+  
+  def to_s
+    super << '-weekend'
+  end
+end

data/lib/chronic/repeaters/repeater_year.rb

@@ -1,64 +1,64 @@
 class Chronic::RepeaterYear < Chronic::Repeater #:nodoc:
-	YEAR_SECONDS =  31536000  # 365 * 24 * 60 * 60
-
-	def initialize(type)
-		super
-		@current_year_start = nil
-	end
-
-	def next(pointer)
-		super
-
-		if !@current_year_start
-			case pointer
-			when :future
-				@current_year_start = Time.construct(@now.year + 1)
-			when :past
-				@current_year_start = Time.construct(@now.year - 1)
-			end
-		else
-			diff = pointer == :future ? 1 : -1
-			@current_year_start = Time.construct(@current_year_start.year + diff)
-		end
-
-		Chronic::Span.new(@current_year_start, Time.construct(@current_year_start.year + 1))
-	end
-
-	def this(pointer = :future)
-		super
-
-		case pointer
-		when :future
-			this_year_start = Time.construct(@now.year, @now.month, @now.day) + Chronic::RepeaterDay::DAY_SECONDS
-			this_year_end = Time.construct(@now.year + 1, 1, 1)
-		when :past
-			this_year_start = Time.construct(@now.year, 1, 1)
-			this_year_end = Time.construct(@now.year, @now.month, @now.day)
-		when :none
-			this_year_start = Time.construct(@now.year, 1, 1)
-			this_year_end = Time.construct(@now.year + 1, 1, 1)
-		end
-
-		Chronic::Span.new(this_year_start, this_year_end)
-	end
-
-	def offset(span, amount, pointer)
-		direction = pointer == :future ? 1 : -1
-
-		sb = span.begin
-		new_begin = Time.construct(sb.year + (amount * direction), sb.month, sb.day, sb.hour, sb.min, sb.sec)
-
-		se = span.end
-		new_end = Time.construct(se.year + (amount * direction), se.month, se.day, se.hour, se.min, se.sec)
-
-		Chronic::Span.new(new_begin, new_end)
-	end
-
-	def width
-		(365 * 24 * 60 * 60)
-	end
-
-	def to_s
-		super << '-year'
-	end
-end
+  YEAR_SECONDS =  31536000  # 365 * 24 * 60 * 60
+  
+  def initialize(type)
+    super
+    @current_year_start = nil
+  end
+  
+  def next(pointer)
+    super
+    
+    if !@current_year_start
+      case pointer
+      when :future
+        @current_year_start = Time.construct(@now.year + 1)
+      when :past
+        @current_year_start = Time.construct(@now.year - 1)
+      end
+    else
+      diff = pointer == :future ? 1 : -1
+      @current_year_start = Time.construct(@current_year_start.year + diff)
+    end
+    
+    Chronic::Span.new(@current_year_start, Time.construct(@current_year_start.year + 1))
+  end
+  
+  def this(pointer = :future)
+    super
+    
+    case pointer
+    when :future
+      this_year_start = Time.construct(@now.year, @now.month, @now.day) + Chronic::RepeaterDay::DAY_SECONDS
+      this_year_end = Time.construct(@now.year + 1, 1, 1)
+    when :past
+      this_year_start = Time.construct(@now.year, 1, 1)
+      this_year_end = Time.construct(@now.year, @now.month, @now.day)
+    when :none
+      this_year_start = Time.construct(@now.year, 1, 1)
+      this_year_end = Time.construct(@now.year + 1, 1, 1)
+    end
+    
+    Chronic::Span.new(this_year_start, this_year_end)
+  end
+  
+  def offset(span, amount, pointer)
+    direction = pointer == :future ? 1 : -1
+    
+    sb = span.begin
+    new_begin = Time.construct(sb.year + (amount * direction), sb.month, sb.day, sb.hour, sb.min, sb.sec)
+    
+    se = span.end
+    new_end = Time.construct(se.year + (amount * direction), se.month, se.day, se.hour, se.min, se.sec)
+    
+    Chronic::Span.new(new_begin, new_end)
+  end
+  
+  def width
+    (365 * 24 * 60 * 60)
+  end
+  
+  def to_s
+    super << '-year'
+  end
+end

data/lib/chronic/scalar.rb

@@ -1,76 +1,95 @@
 module Chronic
 
-	class Scalar < Tag #:nodoc:
-		def self.scan(tokens)
-			# for each token
-			tokens.each_index do |i|
-				if t = self.scan_for_scalars(tokens[i], tokens[i + 1]) then tokens[i].tag(t) end
-				if t = self.scan_for_days(tokens[i], tokens[i + 1]) then tokens[i].tag(t) end
-				if t = self.scan_for_months(tokens[i], tokens[i + 1]) then tokens[i].tag(t) end
-				if t = self.scan_for_years(tokens[i], tokens[i + 1]) then tokens[i].tag(t) end
-			end
-			tokens
-		end
+  class Scalar < Tag #:nodoc:
+    def self.scan(tokens)
+      # for each token
+      tokens.each_index do |i|
+        if t = self.scan_for_scalars(tokens[i], tokens[i + 1]) then tokens[i].tag(t) end
+        if t = self.scan_for_days(tokens[i], tokens[i + 1]) then tokens[i].tag(t) end
+        if t = self.scan_for_months(tokens[i], tokens[i + 1]) then tokens[i].tag(t) end
+        if t = self.scan_for_years(tokens[i], tokens[i + 1]) then tokens[i].tag(t) end
+      end
+      tokens
+    end
+  
+    def self.scan_for_scalars(token, post_token)
+      if token.word =~ /^\d*$/
+        unless post_token && %w{am pm morning afternoon evening night}.include?(post_token)
+          return Scalar.new(token.word.to_i)
+        end
+      end
+      return nil
+    end
+    
+    def self.scan_for_days(token, post_token)
+      if token.word =~ /^\d\d?$/
+        toi = token.word.to_i
+        unless toi > 31 || toi < 1 || (post_token && %w{am pm morning afternoon evening night}.include?(post_token.word))
+          return ScalarDay.new(toi)
+        end
+      end
+      return nil
+    end
+    
+    def self.scan_for_months(token, post_token)
+      if token.word =~ /^\d\d?$/
+        toi = token.word.to_i
+        unless toi > 12 || toi < 1 || (post_token && %w{am pm morning afternoon evening night}.include?(post_token.word))
+          return ScalarMonth.new(toi)
+        end
+      end
+      return nil
+    end
+    
+    def self.scan_for_years(token, post_token)
+      if token.word =~ /^([1-9]\d)?\d\d?$/
+        unless post_token && %w{am pm morning afternoon evening night}.include?(post_token.word)
+          # Ruby 1.9.2 accepts 2 digit years so we need to guess
+          # Of course, this means there is no way to enter a date
+          # that happened before 100.  Probably an OK tradeoff
+          # as it didn't work before, either.
+          year = token.word.to_i
+          if year < 100 
+            this_year = Chronic.time_class.now.year      
+            suffix = this_year.to_s.slice(-2,2).to_i
+            year = this_year + (year - suffix)
 
-		def self.scan_for_scalars(token, post_token)
-			if token.word =~ /^\d*$/ || token.word =~ /^\d\.\d*$/
-				unless post_token && %w{am pm morning afternoon evening night}.include?(post_token)
-					return Scalar.new(token.word.to_f)
-				end
-			end
-			return nil
-		end
+            # We could just split 50/50 to decide if the user
+            # meant the future, however, a user is more likely 
+            # going to use a 2 digit number while looking back 
+            # unless in the near future.  Splitting the difference
+            # at 80/20, however, this could probably be even 
+            # more conservative (90/10 even)
+            year -= 100 if (year - this_year).to_i >= 20
+          end
 
-		def self.scan_for_days(token, post_token)
-			if token.word =~ /^\d\d?$/
-				toi = token.word.to_i
-				unless toi > 31 || toi < 1 || (post_token && %w{am pm morning afternoon evening night}.include?(post_token.word))
-					return ScalarDay.new(toi)
-				end
-			end
-			return nil
-		end
-
-		def self.scan_for_months(token, post_token)
-			if token.word =~ /^\d\d?$/
-				toi = token.word.to_i
-				unless toi > 12 || toi < 1 || (post_token && %w{am pm morning afternoon evening night}.include?(post_token.word))
-					return ScalarMonth.new(toi)
-				end
-			end
-			return nil
-		end
-
-		def self.scan_for_years(token, post_token)
-			if token.word =~ /^([1-9]\d)?\d\d?$/
-				unless post_token && %w{am pm morning afternoon evening night}.include?(post_token.word)
-					return ScalarYear.new(token.word.to_i)
-				end
-			end
-			return nil
-		end
-
-		def to_s
-			'scalar'
-		end
-	end
-
-	class ScalarDay < Scalar #:nodoc:
-		def to_s
-			super << '-day-' << @type.to_s
-		end
-	end
-
-	class ScalarMonth < Scalar #:nodoc:
-		def to_s
-			super << '-month-' << @type.to_s
-		end
-	end
-
-	class ScalarYear < Scalar #:nodoc:
-		def to_s
-			super << '-year-' << @type.to_s
-		end
-	end
+          return ScalarYear.new(year)
+        end
+      end
+      return nil
+    end
+    
+    def to_s
+      'scalar'
+    end
+  end
+  
+  class ScalarDay < Scalar #:nodoc:
+    def to_s
+      super << '-day-' << @type.to_s
+    end
+  end
+  
+  class ScalarMonth < Scalar #:nodoc:
+    def to_s
+      super << '-month-' << @type.to_s
+    end
+  end
+  
+  class ScalarYear < Scalar #:nodoc:
+    def to_s
+      super << '-year-' << @type.to_s
+    end
+  end
 
 end