chronic 0.2.2 → 0.10.2

data/lib/chronic/separator.rb

@@ -1,76 +1,207 @@
 module Chronic
+  class Separator < Tag
 
-  class Separator < Tag #:nodoc:
-    def self.scan(tokens)
-      tokens.each_index do |i|
-        if t = self.scan_for_commas(tokens[i]) then tokens[i].tag(t); next end
-        if t = self.scan_for_slash_or_dash(tokens[i]) then tokens[i].tag(t); next end
-        if t = self.scan_for_at(tokens[i]) then tokens[i].tag(t); next end
-        if t = self.scan_for_in(tokens[i]) then tokens[i].tag(t); next end
+    # Scan an Array of Token objects and apply any necessary Separator
+    # 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_commas(token) then token.tag(t); next end
+        if t = scan_for_dots(token) then token.tag(t); next end
+        if t = scan_for_colon(token) then token.tag(t); next end
+        if t = scan_for_space(token) then token.tag(t); next end
+        if t = scan_for_slash(token) then token.tag(t); next end
+        if t = scan_for_dash(token) then token.tag(t); next end
+        if t = scan_for_quote(token) then token.tag(t); next end
+        if t = scan_for_at(token) then token.tag(t); next end
+        if t = scan_for_in(token) then token.tag(t); next end
+        if t = scan_for_on(token) then token.tag(t); next end
+        if t = scan_for_and(token) then token.tag(t); next end
+        if t = scan_for_t(token) then token.tag(t); next end
+        if t = scan_for_w(token) then token.tag(t); next end
       end
-      tokens
     end
-    
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeparatorComma object.
     def self.scan_for_commas(token)
-      scanner = {/^,$/ => :comma}
-      scanner.keys.each do |scanner_item|
-        return SeparatorComma.new(scanner[scanner_item]) if scanner_item =~ token.word
-      end
-      return nil
-    end
-    
-    def self.scan_for_slash_or_dash(token)
-      scanner = {/^-$/ => :dash,
-                 /^\/$/ => :slash}
-      scanner.keys.each do |scanner_item|
-        return SeparatorSlashOrDash.new(scanner[scanner_item]) if scanner_item =~ token.word
-      end
-      return nil
+      scan_for token, SeparatorComma, { /^,$/ => :comma }
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeparatorDot object.
+    def self.scan_for_dots(token)
+      scan_for token, SeparatorDot, { /^\.$/ => :dot }
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeparatorColon object.
+    def self.scan_for_colon(token)
+      scan_for token, SeparatorColon, { /^:$/ => :colon }
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeparatorSpace object.
+    def self.scan_for_space(token)
+      scan_for token, SeparatorSpace, { /^ $/ => :space }
     end
-    
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeparatorSlash object.
+    def self.scan_for_slash(token)
+      scan_for token, SeparatorSlash, { /^\/$/ => :slash }
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeparatorDash object.
+    def self.scan_for_dash(token)
+      scan_for token, SeparatorDash, { /^-$/ => :dash }
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeparatorQuote object.
+    def self.scan_for_quote(token)
+      scan_for token, SeparatorQuote,
+      {
+        /^'$/ => :single_quote,
+        /^"$/ => :double_quote
+      }
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeparatorAt object.
     def self.scan_for_at(token)
-      scanner = {/^(at|@)$/ => :at}
-      scanner.keys.each do |scanner_item|
-        return SeparatorAt.new(scanner[scanner_item]) if scanner_item =~ token.word
-      end
-      return nil
+      scan_for token, SeparatorAt, { /^(at|@)$/ => :at }
     end
-    
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeparatorIn object.
     def self.scan_for_in(token)
-      scanner = {/^in$/ => :in}
-      scanner.keys.each do |scanner_item|
-        return SeparatorIn.new(scanner[scanner_item]) if scanner_item =~ token.word
-      end
-      return nil
+      scan_for token, SeparatorIn, { /^in$/ => :in }
     end
-    
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeparatorOn object.
+    def self.scan_for_on(token)
+      scan_for token, SeparatorOn, { /^on$/ => :on }
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeperatorAnd Object object.
+    def self.scan_for_and(token)
+      scan_for token, SeparatorAnd, { /^and$/ => :and }
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeperatorT Object object.
+    def self.scan_for_t(token)
+      scan_for token, SeparatorT, { /^t$/ => :T }
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeperatorW Object object.
+    def self.scan_for_w(token)
+      scan_for token, SeparatorW, { /^w$/ => :W }
+    end
+
     def to_s
       'separator'
     end
   end
-  
+
   class SeparatorComma < Separator #:nodoc:
     def to_s
       super << '-comma'
     end
   end
-  
-  class SeparatorSlashOrDash < Separator #:nodoc:
+
+  class SeparatorDot < Separator #:nodoc:
+    def to_s
+      super << '-dot'
+    end
+  end
+
+  class SeparatorColon < Separator #:nodoc:
+    def to_s
+      super << '-colon'
+    end
+  end
+
+  class SeparatorSpace < Separator #:nodoc:
     def to_s
-      super << '-slashordash-' << @type.to_s
+      super << '-space'
     end
   end
-  
+
+  class SeparatorSlash < Separator #:nodoc:
+    def to_s
+      super << '-slash'
+    end
+  end
+
+  class SeparatorDash < Separator #:nodoc:
+    def to_s
+      super << '-dash'
+    end
+  end
+
+  class SeparatorQuote < Separator #:nodoc:
+    def to_s
+      super << '-quote-' << @type.to_s
+    end
+  end
+
   class SeparatorAt < Separator #:nodoc:
     def to_s
       super << '-at'
     end
   end
-  
+
   class SeparatorIn < Separator #:nodoc:
     def to_s
       super << '-in'
     end
   end
 
-end
+  class SeparatorOn < Separator #:nodoc:
+    def to_s
+      super << '-on'
+    end
+  end
+
+  class SeparatorAnd < Separator #:nodoc:
+    def to_s
+      super << '-and'
+    end
+  end
+
+  class SeparatorT < Separator #:nodoc:
+    def to_s
+      super << '-T'
+    end
+  end
+
+  class SeparatorW < Separator #:nodoc:
+    def to_s
+      super << '-W'
+    end
+  end
+
+end

data/lib/chronic/sign.rb

@@ -0,0 +1,49 @@
+module Chronic
+  class Sign < Tag
+
+    # Scan an Array of Token objects and apply any necessary Sign
+    # 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_plus(token) then token.tag(t); next end
+        if t = scan_for_minus(token) then token.tag(t); next end
+      end
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SignPlus object.
+    def self.scan_for_plus(token)
+      scan_for token, SignPlus, { /^\+$/ => :plus }
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SignMinus object.
+    def self.scan_for_minus(token)
+      scan_for token, SignMinus, { /^-$/ => :minus }
+    end
+
+    def to_s
+      'sign'
+    end
+  end
+
+  class SignPlus < Sign #:nodoc:
+    def to_s
+      super << '-plus'
+    end
+  end
+
+  class SignMinus < Sign #:nodoc:
+    def to_s
+      super << '-minus'
+    end
+  end
+
+end

data/lib/chronic/span.rb

@@ -0,0 +1,31 @@
+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
+    # 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,37 @@
+module Chronic
+  # Tokens are tagged with subclassed instances of this class when
+  # they match specific criteria.
+  class Tag
+
+    attr_accessor :type
+
+    # type - The Symbol type of this tag.
+    def initialize(type, options = {})
+      @type = type
+      @options = options
+    end
+
+    # time - Set the start Time for this Tag.
+    def start=(time)
+      @now = time
+    end
+
+    class << self
+      private
+
+      def scan_for(token, klass, items={}, options = {})
+        case items
+        when Regexp
+          return klass.new(token.word, options) if items =~ token.word
+        when Hash
+          items.each do |item, symbol|
+            return klass.new(symbol, options) if item =~ token.word
+          end
+        end
+        nil
+      end
+
+    end
+
+  end
+end

data/lib/chronic/time.rb

@@ -0,0 +1,40 @@
+module Chronic
+  class Time
+    HOUR_SECONDS = 3600 # 60 * 60
+    MINUTE_SECONDS = 60
+    SECOND_SECONDS = 1 # haha, awesome
+    SUBSECOND_SECONDS = 0.001
+
+    # Checks if given number could be hour
+    def self.could_be_hour?(hour)
+      hour >= 0 && hour <= 24
+    end
+
+    # Checks if given number could be minute
+    def self.could_be_minute?(minute)
+      minute >= 0 && minute <= 60
+    end
+
+    # Checks if given number could be second
+    def self.could_be_second?(second)
+      second >= 0 && second <= 60
+    end
+
+    # Checks if given number could be subsecond
+    def self.could_be_subsecond?(subsecond)
+      subsecond >= 0 && subsecond <= 999999
+    end
+
+    # normalize offset in seconds to offset as string +mm:ss or -mm:ss
+    def self.normalize_offset(offset)
+      return offset if offset.is_a?(String)
+      offset = Chronic.time_class.now.to_time.utc_offset unless offset # get current system's UTC offset if offset is nil
+      sign = '+'
+      sign = '-' if offset < 0
+      hours = (offset.abs / 3600).to_i.to_s.rjust(2,'0')
+      minutes = (offset.abs % 3600).to_s.rjust(2,'0')
+      sign + hours + minutes
+    end
+
+  end
+end

data/lib/chronic/time_zone.rb

@@ -1,22 +1,32 @@
 module Chronic
-  class TimeZone < Tag #:nodoc:    
-    def self.scan(tokens)
-      tokens.each_index do |i|
-        if t = self.scan_for_all(tokens[i]) then tokens[i].tag(t); next end
+  class TimeZone < Tag
+
+    # Scan an Array of Token objects and apply any necessary TimeZone
+    # 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); next end
       end
-      tokens
     end
 
+    # token - The Token object we want to scan.
+    #
+    # Returns a new Pointer object.
     def self.scan_for_all(token)
-      scanner = {/[PMCE][DS]T/i => :tz}
-      scanner.keys.each do |scanner_item|
-        return self.new(scanner[scanner_item]) if scanner_item =~ token.word
-      end
-      return nil
+      scan_for token, self,
+      {
+        /[PMCE][DS]T|UTC/i => :tz,
+        /(tzminus)?\d{2}:?\d{2}/ => :tz
+      }
     end
 
     def to_s
       'timezone'
     end
   end
-end
+end

data/lib/chronic/token.rb

@@ -0,0 +1,51 @@
+module Chronic
+  class Token
+
+    attr_accessor :word
+    attr_accessor :tags
+
+    def initialize(word)
+      @word = word
+      @tags = []
+    end
+
+    # Tag this token with the specified tag.
+    #
+    # new_tag - The new Tag object.
+    #
+    # Returns nothing.
+    def tag(new_tag)
+      @tags << new_tag
+    end
+
+    # Remove all tags of the given class.
+    #
+    # tag_class - The tag Class to remove.
+    #
+    # Returns nothing.
+    def untag(tag_class)
+      @tags.delete_if { |m| m.kind_of? tag_class }
+    end
+
+    # Returns true if this token has any tags.
+    def tagged?
+      @tags.size > 0
+    end
+
+    # tag_class - The tag Class to search for.
+    #
+    # Returns The first Tag that matches the given class.
+    def get_tag(tag_class)
+      @tags.find { |m| m.kind_of? tag_class }
+    end
+
+    # Print this Token in a pretty way
+    def to_s
+      @word << '(' << @tags.join(', ') << ') '
+    end
+
+    def inspect
+      to_s
+    end
+  end
+end