chronic_2011 0.1.0

data/lib/chronic/mini_date.rb

@@ -0,0 +1,38 @@
+module Chronic
+  class MiniDate
+    attr_accessor :month, :day
+
+    def self.from_time(time)
+      new(time.month, time.day)
+    end
+
+    def initialize(month, day)
+      unless (1..12).include?(month)
+        raise ArgumentError, "1..12 are valid months"
+      end
+
+      @month = month
+      @day = day
+    end
+
+    def is_between?(md_start, md_end)
+      return false if (@month == md_start.month && @month == md_end.month) &&
+                      (@day < md_start.day || @day > md_end.day)
+      return true if (@month == md_start.month && @day >= md_start.day) ||
+                     (@month == md_end.month && @day <= md_end.day)
+
+      i = (md_start.month % 12) + 1
+
+      until i == md_end.month
+        return true if @month == i
+        i = (i % 12) + 1
+      end
+
+      return false
+    end
+
+    def equals?(other)
+      @month == other.month and @day == other.day
+    end
+  end
+end

data/lib/chronic/numerizer.rb

@@ -0,0 +1,121 @@
+require 'strscan'
+
+module Chronic
+  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
+    ]
+
+    ORDINALS = [
+      ['first', '1'],
+      ['third', '3'],
+      ['fourth', '4'],
+      ['fifth', '5'],
+      ['sixth', '6'],
+      ['seventh', '7'],
+      ['eighth', '8'],
+      ['ninth', '9'],
+      ['tenth', '10']
+    ]
+
+    TEN_PREFIXES = [
+      ['twenty', 20],
+      ['thirty', 30],
+      ['forty', 40],
+      ['fourty', 40], # Common mis-spelling
+      ['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
+
+      ORDINALS.each do |on|
+        string.gsub!(/#{on[0]}/i, '<num>' + on[1] + on[0][-2, 2])
+      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
+
+    class << self
+      private
+
+      def 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
+  end
+end

data/lib/chronic/ordinal.rb

@@ -0,0 +1,47 @@
+module Chronic
+  class Ordinal < Tag
+
+    # Scan an Array of Token objects and apply any necessary Ordinal
+    # tags to each token.
+    #
+    # tokens - An Array of tokens to scan.
+    # options - The Hash of options specified in Chronic::parse.
+    #
+    # Returns an Array of tokens.
+    def self.scan(tokens, options)
+      tokens.each do |token|
+        if t = scan_for_ordinals(token) then token.tag(t) end
+        if t = scan_for_days(token) then token.tag(t) end
+      end
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new Ordinal object.
+    def self.scan_for_ordinals(token)
+      Ordinal.new($1.to_i) if token.word =~ /^(\d*)(st|nd|rd|th)$/
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new Ordinal object.
+    def self.scan_for_days(token)
+      if token.word =~ /^(\d*)(st|nd|rd|th)$/
+        unless $1.to_i > 31 || $1.to_i < 1
+          OrdinalDay.new(token.word.to_i)
+        end
+      end
+    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,32 @@
+module Chronic
+  class Pointer < Tag
+
+    # Scan an Array of Token objects and apply any necessary Pointer
+    # tags to each token.
+    #
+    # tokens - An Array of tokens to scan.
+    # options - The Hash of options specified in Chronic::parse.
+    #
+    # Returns an Array of tokens.
+    def self.scan(tokens, options)
+      tokens.each do |token|
+        if t = scan_for_all(token) then token.tag(t) end
+      end
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new Pointer object.
+    def self.scan_for_all(token)
+      scan_for token, self,
+      {
+        /\bpast\b/ => :past,
+        /\b(?:future|in)\b/ => :future,
+      }
+    end
+
+    def to_s
+      'pointer-' << @type.to_s
+    end
+  end
+end

data/lib/chronic/repeater.rb

@@ -0,0 +1,142 @@
+module Chronic
+  class Repeater < Tag
+
+    # Scan an Array of Token objects and apply any necessary Repeater
+    # tags to each token.
+    #
+    # tokens - An Array of tokens to scan.
+    # options - The Hash of options specified in Chronic::parse.
+    #
+    # Returns an Array of tokens.
+    def self.scan(tokens, options)
+      tokens.each do |token|
+        if t = scan_for_season_names(token) then token.tag(t); next end
+        if t = scan_for_month_names(token) then token.tag(t); next end
+        if t = scan_for_day_names(token) then token.tag(t); next end
+        if t = scan_for_day_portions(token) then token.tag(t); next end
+        if t = scan_for_times(token) then token.tag(t); next end
+        if t = scan_for_units(token) then token.tag(t); next end
+      end
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new Repeater object.
+    def self.scan_for_season_names(token)
+      scan_for token, RepeaterSeasonName,
+      {
+        /^springs?$/ => :spring,
+        /^summers?$/ => :summer,
+        /^(autumn)|(fall)s?$/ => :autumn,
+        /^winters?$/ => :winter
+      }
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new Repeater object.
+    def self.scan_for_month_names(token)
+      scan_for token, RepeaterMonthName,
+      {
+        /^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
+      }
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new Repeater object.
+    def self.scan_for_day_names(token)
+      scan_for token, RepeaterDayName,
+      {
+        /^m[ou]n(day)?$/ => :monday,
+        /^t(ue|eu|oo|u|)s?(day)?$/ => :tuesday,
+        /^we(d|dnes|nds|nns)(day)?$/ => :wednesday,
+        /^th(u|ur|urs|ers)(day)?$/ => :thursday,
+        /^fr[iy](day)?$/ => :friday,
+        /^sat(t?[ue]rday)?$/ => :saturday,
+        /^su[nm](day)?$/ => :sunday
+      }
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new Repeater object.
+    def self.scan_for_day_portions(token)
+      scan_for token, RepeaterDayPortion,
+      {
+        /^ams?$/ => :am,
+        /^pms?$/ => :pm,
+        /^mornings?$/ => :morning,
+        /^afternoons?$/ => :afternoon,
+        /^evenings?$/ => :evening,
+        /^(night|nite)s?$/ => :night
+      }
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new Repeater object.
+    def self.scan_for_times(token)
+      scan_for token, RepeaterTime, /^\d{1,2}(:?\d{2})?([\.:]?\d{2})?$/
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new Repeater object.
+    def self.scan_for_units(token)
+      {
+        /^years?$/ => :year,
+        /^seasons?$/ => :season,
+        /^months?$/ => :month,
+        /^fortnights?$/ => :fortnight,
+        /^weeks?$/ => :week,
+        /^weekends?$/ => :weekend,
+        /^(week|business)days?$/ => :weekday,
+        /^days?$/ => :day,
+        /^hours?$/ => :hour,
+        /^minutes?$/ => :minute,
+        /^seconds?$/ => :second
+      }.each do |item, symbol|
+        if item =~ token.word
+          klass_name = 'Repeater' + symbol.to_s.capitalize
+          klass = Chronic.const_get(klass_name)
+          return klass.new(symbol)
+        end
+      end
+      return nil
+    end
+
+    def <=>(other)
+      width <=> other.width
+    end
+
+    # returns the width (in seconds or months) of this repeatable.
+    def width
+      raise("Repeater#width must be overridden in subclasses")
+    end
+
+    # returns the next occurance of this repeatable.
+    def next(pointer)
+      raise("Start point must be set before calling #next") unless @now
+    end
+
+    def this(pointer)
+      raise("Start point must be set before calling #this") unless @now
+    end
+
+    def to_s
+      'repeater'
+    end
+  end
+end

data/lib/chronic/repeaters/repeater_day.rb

@@ -0,0 +1,53 @@
+module Chronic
+  class RepeaterDay < Repeater #:nodoc:
+    DAY_SECONDS = 86_400 # (24 * 60 * 60)
+
+    def initialize(type)
+      super
+    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
+
+      Span.new(@current_day_start, @current_day_start + DAY_SECONDS)
+    end
+
+    def this(pointer = :future)
+      super
+
+      case pointer
+      when :future
+        day_begin = Chronic.construct(@now.year, @now.month, @now.day, @now.hour)
+        day_end = Chronic.construct(@now.year, @now.month, @now.day) + DAY_SECONDS
+      when :past
+        day_begin = Chronic.construct(@now.year, @now.month, @now.day)
+        day_end = Chronic.construct(@now.year, @now.month, @now.day, @now.hour)
+      when :none
+        day_begin = Chronic.construct(@now.year, @now.month, @now.day)
+        day_end = Chronic.construct(@now.year, @now.month, @now.day) + DAY_SECONDS
+      end
+
+      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
+end

data/lib/chronic/repeaters/repeater_day_name.rb

@@ -0,0 +1,52 @@
+module Chronic
+  class RepeaterDayName < Repeater #:nodoc:
+    DAY_SECONDS = 86400 # (24 * 60 * 60)
+
+    def initialize(type)
+      super
+    end
+
+    def next(pointer)
+      super
+
+      direction = pointer == :future ? 1 : -1
+
+      if !@current_date
+        @current_date = Date.new(@now.year, @now.month, @now.day)
+        @current_date += direction
+
+        day_num = symbol_to_number(@type)
+
+        while @current_date.wday != day_num
+          @current_date += direction
+        end
+      else
+        @current_date += direction * 7
+      end
+      next_date = @current_date.succ
+      Span.new(Chronic.construct(@current_date.year, @current_date.month, @current_date.day), Chronic.construct(next_date.year, next_date.month, next_date.day))
+    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
+end