slaxor-chronic 0.3.1

data/lib/chronic/numerizer/numerizer.rb

@@ -0,0 +1,97 @@
+require 'strscan'
+
+class Numerizer
+
+  DIRECT_NUMS = [
+                  ['eleven', '11'],
+                  ['twelve', '12'],
+                  ['thirteen', '13'],
+                  ['fourteen', '14'],
+                  ['fifteen', '15'],
+                  ['sixteen', '16'],
+                  ['seventeen', '17'],
+                  ['eighteen', '18'],
+                  ['nineteen', '19'],
+                  ['ninteen', '19'], # Common mis-spelling
+                  ['zero', '0'],
+                  ['one', '1'],
+                  ['two', '2'],
+                  ['three', '3'],
+                  ['four(\W|$)', '4\1'],  # The weird regex is so that it matches four but not fourty
+                  ['five', '5'],
+                  ['six(\W|$)', '6\1'],
+                  ['seven(\W|$)', '7\1'],
+                  ['eight(\W|$)', '8\1'],
+                  ['nine(\W|$)', '9\1'],
+                  ['ten', '10'],
+                  ['\ba[\b^$]', '1'] # doesn't make sense for an 'a' at the end to be a 1
+                ]
+
+  TEN_PREFIXES = [ ['twenty', 20],
+                    ['thirty', 30],
+                    ['fourty', 40],
+                    ['fifty', 50],
+                    ['sixty', 60],
+                    ['seventy', 70],
+                    ['eighty', 80],
+                    ['ninety', 90]
+                  ]
+
+  BIG_PREFIXES = [ ['hundred', 100],
+                    ['thousand', 1000],
+                    ['million', 1_000_000],
+                    ['billion', 1_000_000_000],
+                    ['trillion', 1_000_000_000_000],
+                  ]
+
+  def self.numerize(string)
+    string = string.dup
+
+    # preprocess
+    string.gsub!(/ +|([^\d])-([^\d])/, '\1 \2') # will mutilate hyphenated-words but shouldn't matter for date extraction
+    string.gsub!(/a half/, 'haAlf') # take the 'a' out so it doesn't turn into a 1, save the half for the end
+
+    # easy/direct replacements
+
+    DIRECT_NUMS.each do |dn|
+      string.gsub!(/#{dn[0]}/i, '<num>' + dn[1])
+    end
+
+    # ten, twenty, etc.
+
+    TEN_PREFIXES.each do |tp|
+      string.gsub!(/(?:#{tp[0]}) *<num>(\d(?=[^\d]|$))*/i) { '<num>' + (tp[1] + $1.to_i).to_s }
+    end
+
+    TEN_PREFIXES.each do |tp|
+      string.gsub!(/#{tp[0]}/i) { '<num>' + tp[1].to_s }
+    end
+
+    # hundreds, thousands, millions, etc.
+
+    BIG_PREFIXES.each do |bp|
+      string.gsub!(/(?:<num>)?(\d*) *#{bp[0]}/i) { '<num>' + (bp[1] * $1.to_i).to_s}
+      andition(string)
+    end
+
+    # fractional addition
+    # I'm not combining this with the previous block as using float addition complicates the strings
+    # (with extraneous .0's and such )
+    string.gsub!(/(\d+)(?: | and |-)*haAlf/i) { ($1.to_f + 0.5).to_s }
+
+    string.gsub(/<num>/, '')
+  end
+
+  private
+
+  def self.andition(string)
+    sc = StringScanner.new(string)
+    while(sc.scan_until(/<num>(\d+)( | and )<num>(\d+)(?=[^\w]|$)/i))
+      if sc[2] =~ /and/ || sc[1].size > sc[3].size
+        string[(sc.pos - sc.matched_size)..(sc.pos-1)] = '<num>' + (sc[1].to_i + sc[3].to_i).to_s
+        sc.reset
+      end
+    end
+  end
+
+end

data/lib/chronic/ordinal.rb

@@ -0,0 +1,40 @@
+module Chronic
+
+  class Ordinal < Tag #:nodoc:
+    def self.scan(tokens)
+      # for each token
+      tokens.each_index do |i|
+        if t = self.scan_for_ordinals(tokens[i]) then tokens[i].tag(t) end
+        if t = self.scan_for_days(tokens[i]) then tokens[i].tag(t) end
+      end
+      tokens
+    end
+
+    def self.scan_for_ordinals(token)
+      if token.word =~ /^(\d*)(st|nd|rd|th)$/
+        return Ordinal.new($1.to_i)
+      end
+      return nil
+    end
+
+    def self.scan_for_days(token)
+      if token.word =~ /^(\d*)(st|nd|rd|th)$/
+        unless $1.to_i > 31 || $1.to_i < 1
+          return OrdinalDay.new(token.word.to_i)
+        end
+      end
+      return nil
+    end
+
+    def to_s
+      'ordinal'
+    end
+  end
+
+  class OrdinalDay < Ordinal #:nodoc:
+    def to_s
+      super << '-day-' << @type.to_s
+    end
+  end
+
+end

data/lib/chronic/pointer.rb

@@ -0,0 +1,27 @@
+module Chronic
+
+  class Pointer < Tag #:nodoc:
+    def self.scan(tokens)
+      # for each token
+      tokens.each_index do |i|
+        if t = self.scan_for_all(tokens[i]) then tokens[i].tag(t) end
+      end
+      tokens
+    end
+
+    def self.scan_for_all(token)
+      scanner = {/\bpast\b/ => :past,
+                 /\bfuture\b/ => :future,
+                 /\bin\b/ => :future}
+      scanner.keys.each do |scanner_item|
+        return self.new(scanner[scanner_item]) if scanner_item =~ token.word
+      end
+      return nil
+    end
+
+    def to_s
+      'pointer-' << @type.to_s
+    end
+  end
+
+end

data/lib/chronic/repeater.rb

@@ -0,0 +1,129 @@
+class Chronic::Repeater < Chronic::Tag #:nodoc:
+  def self.scan(tokens, options)
+    # for each token
+    tokens.each_index do |i|
+      if t = self.scan_for_season_names(tokens[i]) then tokens[i].tag(t); next end
+      if t = self.scan_for_month_names(tokens[i]) then tokens[i].tag(t); next end
+      if t = self.scan_for_day_names(tokens[i]) then tokens[i].tag(t); next end
+      if t = self.scan_for_day_portions(tokens[i]) then tokens[i].tag(t); next end
+      if t = self.scan_for_times(tokens[i], options) then tokens[i].tag(t); next end
+      if t = self.scan_for_units(tokens[i]) then tokens[i].tag(t); next end
+    end
+    tokens
+  end
+
+  def self.scan_for_season_names(token)
+    scanner = {/^springs?$/ => :spring,
+               /^summers?$/ => :summer,
+               /^(autumn)|(fall)s?$/ => :autumn,
+               /^winters?$/ => :winter}
+    scanner.keys.each do |scanner_item|
+      return Chronic::RepeaterSeasonName.new(scanner[scanner_item]) if scanner_item =~ token.word
+    end
+
+    return nil
+  end
+
+  def self.scan_for_month_names(token)
+    scanner = {/^jan\.?(uary)?$/ => :january,
+               /^feb\.?(ruary)?$/ => :february,
+               /^mar\.?(ch)?$/ => :march,
+               /^apr\.?(il)?$/ => :april,
+               /^may$/ => :may,
+               /^jun\.?e?$/ => :june,
+               /^jul\.?y?$/ => :july,
+               /^aug\.?(ust)?$/ => :august,
+               /^sep\.?(t\.?|tember)?$/ => :september,
+               /^oct\.?(ober)?$/ => :october,
+               /^nov\.?(ember)?$/ => :november,
+               /^dec\.?(ember)?$/ => :december}
+    scanner.keys.each do |scanner_item|
+      return Chronic::RepeaterMonthName.new(scanner[scanner_item]) if scanner_item =~ token.word
+    end
+    return nil
+  end
+
+  def self.scan_for_day_names(token)
+    scanner = {/^m[ou]n(day)?$/ => :monday,
+               /^t(ue|eu|oo|u|)s(day)?$/ => :tuesday,
+               /^tue$/ => :tuesday,
+               /^we(dnes|nds|nns)day$/ => :wednesday,
+               /^wed$/ => :wednesday,
+               /^th(urs|ers)day$/ => :thursday,
+               /^thu$/ => :thursday,
+               /^fr[iy](day)?$/ => :friday,
+               /^sat(t?[ue]rday)?$/ => :saturday,
+               /^su[nm](day)?$/ => :sunday}
+    scanner.keys.each do |scanner_item|
+      return Chronic::RepeaterDayName.new(scanner[scanner_item]) if scanner_item =~ token.word
+    end
+    return nil
+  end
+
+  def self.scan_for_day_portions(token)
+    scanner = {/^ams?$/ => :am,
+               /^pms?$/ => :pm,
+               /^mornings?$/ => :morning,
+               /^afternoons?$/ => :afternoon,
+               /^evenings?$/ => :evening,
+               /^(night|nite)s?$/ => :night}
+    scanner.keys.each do |scanner_item|
+      return Chronic::RepeaterDayPortion.new(scanner[scanner_item]) if scanner_item =~ token.word
+    end
+    return nil
+  end
+
+  def self.scan_for_times(token, options)
+    if token.word =~ /^\d{1,2}(:?\d{2})?([\.:]?\d{2})?$/
+      return Chronic::RepeaterTime.new(token.word, options)
+    end
+    return nil
+  end
+
+  def self.scan_for_units(token)
+    scanner = {/^years?$/ => :year,
+               /^seasons?$/ => :season,
+               /^months?$/ => :month,
+               /^fortnights?$/ => :fortnight,
+               /^weeks?$/ => :week,
+               /^weekends?$/ => :weekend,
+               /^(week|business)days?$/ => :weekday,
+               /^days?$/ => :day,
+               /^hours?$/ => :hour,
+               /^minutes?$/ => :minute,
+               /^seconds?$/ => :second}
+    scanner.keys.each do |scanner_item|
+      if scanner_item =~ token.word
+        klass_name = 'Chronic::Repeater' + scanner[scanner_item].to_s.capitalize
+        klass = eval(klass_name)
+        return klass.new(scanner[scanner_item])
+      end
+    end
+    return nil
+  end
+
+  def <=>(other)
+    width <=> other.width
+  end
+
+  # returns the width (in seconds or months) of this repeatable.
+  def width
+    raise("Repeatable#width must be overridden in subclasses")
+  end
+
+  # returns the next occurance of this repeatable.
+  def next(pointer)
+    !@now.nil? || raise("Start point must be set before calling #next")
+    [:future, :none, :past].include?(pointer) || raise("First argument 'pointer' must be one of :past or :future")
+    #raise("Repeatable#next must be overridden in subclasses")
+  end
+
+  def this(pointer)
+    !@now.nil? || raise("Start point must be set before calling #this")
+    [:future, :past, :none].include?(pointer) || raise("First argument 'pointer' must be one of :past, :future, :none")
+  end
+
+  def to_s
+    'repeater'
+  end
+end

data/lib/chronic/repeaters/repeater_day.rb

@@ -0,0 +1,52 @@
+class Chronic::RepeaterDay < Chronic::Repeater #:nodoc:
+  DAY_SECONDS = 86_400 # (24 * 60 * 60)
+
+  def initialize(type)
+    super
+    @current_day_start = nil
+  end
+
+  def next(pointer)
+    super
+
+    if !@current_day_start
+      @current_day_start = Chronic.time_class.local(@now.year, @now.month, @now.day)
+    end
+
+    direction = pointer == :future ? 1 : -1
+    @current_day_start += direction * DAY_SECONDS
+
+    Chronic::Span.new(@current_day_start, @current_day_start + DAY_SECONDS)
+  end
+
+  def this(pointer = :future)
+    super
+
+    case pointer
+    when :future
+      day_begin = Time.construct(@now.year, @now.month, @now.day, @now.hour + 1)
+      day_end = Time.construct(@now.year, @now.month, @now.day) + DAY_SECONDS
+    when :past
+      day_begin = Time.construct(@now.year, @now.month, @now.day)
+      day_end = Time.construct(@now.year, @now.month, @now.day, @now.hour)
+    when :none
+      day_begin = Time.construct(@now.year, @now.month, @now.day)
+      day_end = Time.construct(@now.year, @now.month, @now.day) + DAY_SECONDS
+    end
+
+    Chronic::Span.new(day_begin, day_end)
+  end
+
+  def offset(span, amount, pointer)
+    direction = pointer == :future ? 1 : -1
+    span + direction * amount * DAY_SECONDS
+  end
+
+  def width
+    DAY_SECONDS
+  end
+
+  def to_s
+    super << '-day'
+  end
+end

data/lib/chronic/repeaters/repeater_day_name.rb

@@ -0,0 +1,51 @@
+class Chronic::RepeaterDayName < Chronic::Repeater #:nodoc:
+  DAY_SECONDS = 86400 # (24 * 60 * 60)
+
+  def initialize(type)
+    super
+    @current_day_start = nil
+  end
+
+  def next(pointer)
+    super
+
+    direction = pointer == :future ? 1 : -1
+
+    if !@current_day_start
+      @current_day_start = Time.construct(@now.year, @now.month, @now.day)
+      @current_day_start += direction * DAY_SECONDS
+
+      day_num = symbol_to_number(@type)
+
+      while @current_day_start.wday != day_num
+        @current_day_start += direction * DAY_SECONDS
+      end
+    else
+      @current_day_start += direction * 7 * DAY_SECONDS
+    end
+
+    Chronic::Span.new(@current_day_start, @current_day_start + DAY_SECONDS)
+  end
+
+  def this(pointer = :future)
+    super
+
+    pointer = :future if pointer == :none
+    self.next(pointer)
+  end
+
+  def width
+    DAY_SECONDS
+  end
+
+  def to_s
+    super << '-dayname-' << @type.to_s
+  end
+
+  private
+
+  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_day_portion.rb

@@ -0,0 +1,94 @@
+class Chronic::RepeaterDayPortion < Chronic::Repeater #:nodoc:
+  @@morning = (6 * 60 * 60)..(12 * 60 * 60) # 6am-12am
+  @@afternoon = (13 * 60 * 60)..(17 * 60 * 60) # 1pm-5pm
+  @@evening = (17 * 60 * 60)..(20 * 60 * 60) # 5pm-8pm
+  @@night = (20 * 60 * 60)..(24 * 60 * 60) # 8pm-12pm
+
+  def initialize(type)
+    super
+    @current_span = nil
+
+    if type.kind_of? Integer
+      @range = (@type * 60 * 60)..((@type + 12) * 60 * 60)
+    else
+      lookup = {:am => 0..(12 * 60 * 60 - 1),
+                :pm => (12 * 60 * 60)..(24 * 60 * 60 - 1),
+                :morning => @@morning,
+                :afternoon => @@afternoon,
+                :evening => @@evening,
+                :night => @@night}
+      @range = lookup[type]
+      lookup[type] || raise("Invalid type '#{type}' for RepeaterDayPortion")
+    end
+    @range || raise("Range should have been set by now")
+  end
+
+  def next(pointer)
+    super
+
+    full_day = 60 * 60 * 24
+
+    if !@current_span
+      now_seconds = @now - Time.construct(@now.year, @now.month, @now.day)
+      if now_seconds < @range.begin
+        case pointer
+        when :future
+          range_start = Time.construct(@now.year, @now.month, @now.day) + @range.begin
+        when :past
+          range_start = Time.construct(@now.year, @now.month, @now.day) - full_day + @range.begin
+        end
+      elsif now_seconds > @range.end
+        case pointer
+        when :future
+          range_start = Time.construct(@now.year, @now.month, @now.day) + full_day + @range.begin
+        when :past
+          range_start = Time.construct(@now.year, @now.month, @now.day) + @range.begin
+        end
+      else
+        case pointer
+        when :future
+          range_start = Time.construct(@now.year, @now.month, @now.day) + full_day + @range.begin
+        when :past
+          range_start = Time.construct(@now.year, @now.month, @now.day) - full_day + @range.begin
+        end
+      end
+
+      @current_span = Chronic::Span.new(range_start, range_start + (@range.end - @range.begin))
+    else
+      case pointer
+      when :future
+        @current_span += full_day
+      when :past
+        @current_span -= full_day
+      end
+    end
+  end
+
+  def this(context = :future)
+    super
+
+    range_start = Time.construct(@now.year, @now.month, @now.day) + @range.begin
+    @current_span = Chronic::Span.new(range_start, range_start + (@range.end - @range.begin))
+  end
+
+  def offset(span, amount, pointer)
+    @now = span.begin
+    portion_span = self.next(pointer)
+    direction = pointer == :future ? 1 : -1
+    portion_span + (direction * (amount - 1) * Chronic::RepeaterDay::DAY_SECONDS)
+  end
+
+  def width
+    @range || raise("Range has not been set")
+    return @current_span.width if @current_span
+    if @type.kind_of? Integer
+      return (12 * 60 * 60)
+    else
+      @range.end - @range.begin
+    end
+  end
+
+  def to_s
+    super << '-dayportion-' << @type.to_s
+  end
+end