chronic-davispuh 0.10.2.v0.1da32066b3f46f2506b3471e39557497e34afa27

data/lib/chronic/span.rb

@@ -0,0 +1,32 @@
+module Chronic
+  # A Span represents a range of time. Since this class extends
+  # Range, you can use #begin and #end to get the beginning and
+  # ending times of the span (they will be of class Time)
+  class Span < Range
+    attr_accessor :precision
+    # Returns the width of this span in seconds
+    def width
+      (self.end - self.begin).to_i
+    end
+
+    # Add a number of seconds to this span, returning the
+    # resulting Span
+    def +(seconds)
+      Span.new(self.begin + seconds, self.end + seconds)
+    end
+
+    # Subtract a number of seconds to this span, returning the
+    # resulting Span
+    def -(seconds)
+      self + -seconds
+    end
+
+    # Prints this span in a nice fashion
+    def to_s
+      '(' << self.begin.to_s << '...' << self.end.to_s << ')'
+    end
+
+    alias :cover? :include? if RUBY_VERSION =~ /^1.8/
+
+  end
+end

data/lib/chronic/tag.rb

@@ -0,0 +1,84 @@
+module Chronic
+  # Tokens are tagged with subclassed instances of this class when
+  # they match specific criteria.
+  class Tag
+
+    attr_accessor :type
+    attr_accessor :width
+
+    # type - The Symbol type of this tag.
+    def initialize(type, width = nil, options = {})
+      @type = type
+      @width = width
+      @options = options
+    end
+
+    class << self
+      # Public: Scan an Array of Token objects.
+      #
+      # tokens  - An Array of tokens to scan.
+      # options - The Hash of options specified in Chronic::parse.
+      #
+      # Returns an Array of tokens.
+      def scan(tokens, options)
+        raise NotImplementedError, 'Subclasses must override scan!'
+      end
+
+      private
+
+      # Internal: Match item and create respective Tag class.
+      #           When item is a Symbol it will match only when it's identical to Token.
+      #           When it's a String it will case-insesitively match partial token,
+      #           but only if item's last char have different type than token text's next char.
+      #           When item is a Regexp it will match by it.
+      #
+      # item    - Item to match. It can be String, Symbol or Regexp.
+      # klass   - Tag class to create.
+      # symbol  - Tag type as symbol or string to pass to Tag class.
+      # token   - Token to match against.
+      # options - Options as hash to pass to Tag class.
+      #
+      # Returns an instance of specified Tag klass or nil if item didn't match.
+      def match_item(item, klass, symbol, token, options)
+        match = false
+        case item
+        when String
+          item_type = Tokenizer.char_type(item.to_s[-1])
+          text_type = token.text[token.position+item.length]
+          text_type = Tokenizer.char_type(text_type) if text_type
+          compatible = true
+          compatible = item_type != text_type if text_type && (item_type == :letter || item_type == :digit)
+          match = compatible && token.text[token.position, item.length].casecmp(item).zero?
+        when Symbol
+          match = token.word == item.to_s
+        when Regexp
+          match = token.word =~ item
+        end
+        return klass.new(symbol, nil, options) if match
+        nil
+      end
+
+      # Internal: Scan for specified items and create respective Tag class.
+      #
+      # token   - Token to match against.
+      # klass   - Tag class to create.
+      # items   - Item(s) to match. It can be Hash, String, Symbol or Regexp.
+      #           Hash keys can be String, Symbol or Regexp, but values much be Symbol.
+      # options - Options as hash to pass to Tag class.
+      #
+      # Returns an instance of specified Tag klass or nil if item(s) didn't match.
+      def scan_for(token, klass, items, options = {})
+        if items.kind_of?(Hash)
+          items.each do |item, symbol|
+            scanned = match_item(item, klass, symbol, token, options)
+            return scanned if scanned
+          end
+        else
+          return match_item(items, klass, token.word, token, options)
+        end
+        nil
+      end
+    end
+
+  end
+end

data/lib/chronic/tags/day_name.rb

@@ -0,0 +1,34 @@
+module Chronic
+  class DayName < Tag
+
+    # Scan an Array of Token objects and apply any necessary DayName
+    # 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|
+        token.tag scan_for(token, self, patterns, options)
+      end
+    end
+
+    def self.patterns
+      @@patterns ||= {
+        /^m[ou]n(day)?$/i             => :monday,
+        /^t(ue|eu|oo|u)s?(day)?$/i    => :tuesday,
+        /^we(d|dnes|nds|nns)(day)?$/i => :wednesday,
+        /^th(u|ur|urs|ers)(day)?$/i   => :thursday,
+        /^fr[iy](day)?$/i             => :friday,
+        /^sat(t?[ue]rday)?$/i         => :saturday,
+        /^su[nm](day)?$/i             => :sunday
+      }
+    end
+
+    def to_s
+      'dayname-' << @type.to_s
+    end
+  end
+
+end

data/lib/chronic/tags/day_portion.rb

@@ -0,0 +1,33 @@
+module Chronic
+  class DayPortion < Tag
+
+    # Scan an Array of Token objects and apply any necessary DayPortion
+    # 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|
+        token.tag scan_for(token, self, patterns, options)
+      end
+    end
+
+    def self.patterns
+      @@patterns ||= {
+        /^ams?$/i => :am,
+        /^pms?$/i => :pm,
+        'a.m.'    => :am,
+        'p.m.'    => :pm,
+        'a'       => :am,
+        'p'       => :pm
+      }
+    end
+
+    def to_s
+      'dayportion-' << @type.to_s
+    end
+  end
+
+end

data/lib/chronic/tags/day_special.rb

@@ -0,0 +1,30 @@
+module Chronic
+  class DaySpecial < Tag
+
+    # Scan an Array of Token objects and apply any necessary SeasonName
+    # 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|
+        token.tag scan_for(token, self, patterns, options)
+      end
+    end
+
+    def self.patterns
+      @@patterns ||= {
+        /^yesterday$/i => :yesterday,
+        /^today$/i     => :today,
+        /^tomorrow$/i  => :tomorrow
+      }
+    end
+
+    def to_s
+      'dayspecial-' << @type.to_s
+    end
+  end
+
+end

data/lib/chronic/tags/grabber.rb

@@ -0,0 +1,29 @@
+module Chronic
+  class Grabber < Tag
+
+    # Scan an Array of Tokens and apply any necessary Grabber tags to
+    # each token.
+    #
+    # tokens  - An Array of Token objects to scan.
+    # options - The Hash of options specified in Chronic::parse.
+    #
+    # Returns an Array of Token objects.
+    def self.scan(tokens, options)
+      tokens.each do |token|
+        token.tag scan_for(token, self, patterns, options)
+      end
+    end
+
+    def self.patterns
+      @@patterns ||= {
+        'last' => :last,
+        'this' => :this,
+        'next' => :next
+      }
+    end
+
+    def to_s
+      'grabber-' << @type.to_s
+    end
+  end
+end

data/lib/chronic/tags/keyword.rb

@@ -0,0 +1,63 @@
+module Chronic
+  class Keyword < Tag
+
+    # Scan an Array of Token objects and apply any necessary Keyword
+    # 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|
+        token.tag scan_for(token, KeywordAt,  { /^(at|@)$/i => :at  })
+        token.tag scan_for(token, KeywordIn,  { 'in'        => :in  })
+        token.tag scan_for(token, KeywordOn,  { 'on'        => :on  })
+        token.tag scan_for(token, KeywordAnd, { 'and'       => :and })
+        token.tag scan_for(token, KeywordTo,  { 'to'        => :to  })
+        token.tag scan_for(token, KeywordQ,   { :Q          => :Q   })
+      end
+    end
+
+    def to_s
+      'keyword'
+    end
+  end
+
+  class KeywordAt < Keyword #:nodoc:
+    def to_s
+      super << '-at'
+    end
+  end
+
+  class KeywordIn < Keyword #:nodoc:
+    def to_s
+      super << '-in'
+    end
+  end
+
+  class KeywordOn < Keyword #:nodoc:
+    def to_s
+      super << '-on'
+    end
+  end
+
+  class KeywordAnd < Keyword #:nodoc:
+    def to_s
+      super << '-and'
+    end
+  end
+
+  class KeywordTo < Keyword #:nodoc:
+    def to_s
+      super << '-to'
+    end
+  end
+
+  class KeywordQ < Keyword #:nodoc:
+    def to_s
+      super << '-q'
+    end
+  end
+
+end

data/lib/chronic/tags/month_name.rb

@@ -0,0 +1,39 @@
+module Chronic
+  class MonthName < Tag
+
+    # Scan an Array of Token objects and apply any necessary MonthName
+    # 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|
+        token.tag scan_for(token, self, patterns, options)
+      end
+    end
+
+    def self.patterns
+      @@patterns ||= {
+        /^jan[:\.]?(uary)?$/i           => :january,
+        /^feb[:\.]?(ruary)?$/i          => :february,
+        /^mar[:\.]?(ch)?$/i             => :march,
+        /^apr[:\.]?(il)?$/i             => :april,
+        /^may$/i                        => :may,
+        /^jun[:\.]?e?$/i                => :june,
+        /^jul[:\.]?y?$/i                => :july,
+        /^aug[:\.]?(ust)?$/i            => :august,
+        /^sep[:\.]?(t[:\.]?|tember)?$/i => :september,
+        /^oct[:\.]?(ober)?$/i           => :october,
+        /^nov[:\.]?(ember)?$/i          => :november,
+        /^dec[:\.]?(ember)?$/i          => :december
+      }
+    end
+
+    def to_s
+      'monthname-' << @type.to_s
+    end
+  end
+
+end

data/lib/chronic/tags/ordinal.rb

@@ -0,0 +1,52 @@
+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_index do |i|
+        if tokens[i].word =~ /^\d+$/ and tokens[i + 1] and tokens[i + 1].word =~ /^st|nd|rd|th|\.$/
+          width = tokens[i].word.length
+          ordinal = tokens[i].word.to_i
+          tokens[i].tag(Ordinal.new(ordinal, width))
+          tokens[i].tag(OrdinalDay.new(ordinal, width)) if Chronic::Date::could_be_day?(ordinal, width)
+          tokens[i].tag(OrdinalMonth.new(ordinal, width)) if Chronic::Date::could_be_month?(ordinal, width)
+          if Chronic::Date::could_be_year?(ordinal, width)
+            year = Chronic::Date::make_year(ordinal, options[:ambiguous_year_future_bias])
+            tokens[i].tag(OrdinalYear.new(year.to_i, width))
+          end
+        elsif tokens[i].word =~ /^second$/
+          tokens[i].tag(Ordinal.new(2, 1))
+        end
+      end
+    end
+
+    def to_s
+      'ordinal'
+    end
+  end
+
+  class OrdinalDay < Ordinal #:nodoc:
+    def to_s
+      super << '-day-' << @type.to_s
+    end
+  end
+
+  class OrdinalMonth < Ordinal #:nodoc:
+    def to_s
+      super << '-month-' << @type.to_s
+    end
+  end
+
+  class OrdinalYear < Ordinal #:nodoc:
+    def to_s
+      super << '-year-' << @type.to_s
+    end
+  end
+
+end

data/lib/chronic/tags/pointer.rb

@@ -0,0 +1,28 @@
+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|
+        token.tag scan_for(token, self, patterns, options)
+      end
+    end
+
+    def self.patterns
+      @@patterns ||= {
+        /^ago|before|prior|till|to$/i     => :past,
+        /^future|hence|from|after|past$/i => :future
+      }
+    end
+
+    def to_s
+      'pointer-' << @type.to_s
+    end
+  end
+end

data/lib/chronic/tags/rational.rb

@@ -0,0 +1,35 @@
+module Chronic
+  class Rational < Tag
+
+    # Scan an Array of Token objects and apply any necessary Keyword
+    # 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|
+        token.tag scan_for(token, RationalQuarter,  { 'quarter' => Rational(1, 4) })
+        token.tag scan_for(token, RationalHalf,     { 'half'    => Rational(1, 2) })
+      end
+    end
+
+    def to_s
+      'rational'
+    end
+  end
+
+  class RationalQuarter < Rational #:nodoc:
+    def to_s
+      super << '-quarter'
+    end
+  end
+
+  class RationalHalf < Rational #:nodoc:
+    def to_s
+      super << '-half'
+    end
+  end
+
+end