chronic-davispuh 0.10.2.v0.1da32066b3f46f2506b3471e39557497e34afa27

data/lib/chronic/objects/date_time_object.rb

@@ -0,0 +1,64 @@
+require 'chronic/handlers/date_time'
+
+module Chronic
+  class DateTimeObject < HandlerObject
+    include DateStructure
+    include TimeStructure
+    include TimeZoneStructure
+
+    def initialize(tokens, token_index, definitions, local_date, options)
+      super
+      @normalized = false
+      match(tokens, @index, definitions)
+    end
+
+    def normalize!
+      return if @normalized
+      adjust!
+      @normalized = true
+    end
+
+    def is_valid?
+      normalize!
+      return false if @year.nil? or @month.nil? or @day.nil? or @hour.nil? or @minute.nil? or @second.nil?
+      ::Date.valid_date?(@year, @month, @day)
+    end
+
+    def get_end
+      year = @year
+      month = @month
+      day = @day
+      hour = @hour
+      minute = @minute
+      second = @second
+      if @precision == :subsecond
+        minute, second = Time::add_second(minute, second, 1.0 / @subsecond_size)
+      else
+        minute, second = Time::add_second(minute, second)
+      end
+      [year, month, day, hour, minute, second]
+    end
+
+    def to_span
+      span_start = Chronic.construct(@year, @month, @day, @hour, @minute, @second, self)
+      end_year, end_month, end_day, end_hour, end_minute, end_second = get_end
+      span_end = Chronic.construct(end_year, end_month, end_day, end_hour, end_minute, end_second, self)
+      Span.new(span_start, span_end, true)
+    end
+
+    def to_s
+      "year #{@year.inspect}, month #{@month.inspect}, day #{@day.inspect}, hour #{@hour.inspect}, minute #{@minute.inspect}, second #{@second.inspect}, subsecond #{@subsecond.inspect}"
+    end
+
+    protected
+
+    def adjust!
+      @second ||= 0
+      @second += @subsecond if @subsecond
+      @subsecond = 0
+    end
+
+    include DateTimeHandlers
+
+  end
+end

data/lib/chronic/objects/handler_object.rb

@@ -0,0 +1,81 @@
+require 'chronic/handlers/general'
+
+module Chronic
+  class HandlerObject
+
+    attr_accessor :local_date
+    attr_reader :begin
+    attr_reader :width
+    attr_reader :precision
+    def initialize(tokens, token_index, definitions, local_date, options)
+      @tokens = tokens
+      @begin = token_index
+      @local_date = local_date
+      @options = options
+      @context = @options[:context]
+      @width = 0
+      @index = token_index
+    end
+
+    def end
+      @begin + @width - 1
+    end
+
+    def range
+      @begin..(@begin + @width - 1)
+    end
+
+    def overlap?(r2)
+      r1 = range
+      (r1.begin <= r2.end) and (r2.begin <= r1.end)
+    end
+
+    def is_valid?
+      false
+    end
+
+    def local_day
+      [@local_date.year, @local_date.month, @local_date.day]
+    end
+
+    def local_time
+      [@local_date.hour, @local_date.min, @local_date.sec + @local_date.usec.to_f / (10 ** 6)]
+    end
+
+    protected
+
+    def match(tokens, token_index, definitions)
+      definitions.each do |definition|
+        if Handler.match(tokens, token_index, definition.first)
+          self.method(definition.last).call
+          @width = @index - @begin
+          puts "\nHandler: #{self.class.name}.#{definition.last.to_s} @ #{@begin}-#{self.end} =>\n=======> #{self}" if Chronic.debug and @width > 0
+          return
+        end
+      end
+      @width = 0
+    end
+
+    def get_sign
+      (@context == :past) ? -1 : ((@context == :future) ? 1 : 0)
+    end
+
+    def get_modifier
+      (@grabber == :last) ? -1 : ((@grabber == :next) ? 1 : 0)
+    end
+
+    def next_tag
+      @index += 1
+    end
+
+    def handle_possible(tag)
+      if @tokens[@index].get_tag(tag)
+        next_tag
+        return true
+      end
+      false
+    end
+
+  end
+
+end

data/lib/chronic/objects/narrow_object.rb

@@ -0,0 +1,85 @@
+require 'chronic/handlers/narrow'
+
+module Chronic
+  class NarrowObject < HandlerObject
+    attr_reader :number
+    attr_reader :wday
+    attr_reader :unit
+    def initialize(tokens, token_index, definitions, local_date, options)
+      super
+      handle_possible(SeparatorSpace) if handle_possible(KeywordOn)
+      match(tokens, @index, definitions)
+    end
+
+    def is_valid?
+      true
+    end
+
+    def to_s
+      "number #{@number.inspect}, wday #{@wday.inspect}, unit #{@unit.inspect}, grabber #{@grabber.inspect}"
+    end
+
+    def to_span(span = nil, timezone = nil)
+      start = @local_date
+      start = span.begin if span
+      hour, minute, second, utc_offset = Time::split(start)
+      end_hour = end_minute = end_second = 0
+      modifier = get_modifier
+      sign = get_sign
+      if @wday
+        diff = Date::wday_diff(start, @wday, 0, 0)
+        diff += Date::WEEK_DAYS if diff < 0
+        diff += Date::WEEK_DAYS * (@number - 1) if @number > 1
+        year, month, day = Date::add_day(start.year, start.month, start.day, diff)
+        end_year, end_month, end_day = year, month, day
+        end_hour += Date::DAY_HOURS
+      else
+        case @unit
+        when :year
+          # TODO
+          raise "Not Implemented NarrowObject #{@unit.inspect}"
+        when :season
+          # TODO
+          raise "Not Implemented NarrowObject #{@unit.inspect}"
+        when :quarter
+          this_quarter = Date::get_quarter_index(start.month)
+          diff = Date::quarter_diff(this_quarter, @number, modifier, sign)
+          year, quarter = Date::add_quarter(start.year, this_quarter, diff)
+          year = start.year if span
+          month = Date::QUARTERS[quarter]
+          end_year, next_quarter = Date::add_quarter(year, quarter)
+          end_month = Date::QUARTERS[next_quarter]
+          day = end_day = 1
+          hour = minute = second = 0
+        when :month
+          day = start.day
+          year, month = Date::add_month(start.year, start.month, @number - 1)
+          end_year, end_month, end_day = year, month, day
+          end_year, end_month = Date::add_month(year, month, 1)
+        when :fortnight, :week, :weekend, :weekday
+          # TODO
+          raise "Not Implemented NarrowObject #{@unit.inspect}"
+        when :day
+          year, month, day = Date::add_day(start.year, start.month, start.day, @number - 1)
+          end_year, end_month, end_day = year, month, day
+          end_hour += Date::DAY_HOURS
+        when :morning, :noon, :afternoon, :evening, :night, :midnight, :hour, :minute, :second, :milisecond
+          # TODO
+          raise "Not Implemented NarrowObject #{@unit.inspect}"
+        else
+          raise "Uknown unit #{@unit.inspect}!"
+        end
+      end
+      span_start = Chronic.construct(year, month, day, hour, minute, second, timezone)
+      return nil if span and span_start >= span.end
+      span_end = Chronic.construct(end_year, end_month, end_day, end_hour, end_minute, end_second, timezone)
+      span_end = span.end if span and span_end > span.end
+      Span.new(span_start, span_end, true)
+    end
+
+    protected
+
+    include NarrowHandlers
+
+  end
+end

data/lib/chronic/objects/time_object.rb

@@ -0,0 +1,96 @@
+require 'chronic/handlers/time'
+
+module Chronic
+  class TimeObject < HandlerObject
+    include TimeStructure
+    attr_reader :time_special
+    attr_reader :day_portion
+    attr_reader :ambiguous
+    def initialize(tokens, token_index, definitions, local_date, options)
+      super
+      @ambiguous = true
+      @ambiguous = false if @options[:hours24] == true or @options[:ambiguous_time_range] == :none
+      @normalized = false
+      match(tokens, @index, definitions)
+    end
+
+    def normalize!
+      return if @normalized
+      if @hour
+        if @day_portion == :am       # 0am to 12pm
+          @hour = 0 if @hour == 12
+          @ambiguous = false
+        elsif @time_special == :morning
+          @ambiguous = false
+        elsif @day_portion == :pm or # 12pm to 0am
+              @time_special == :afternoon or
+              @time_special == :evening
+          @hour += 12 if @hour < 12
+          @ambiguous = false
+        elsif @time_special == :night
+          @hour = 0 if @hour == 12
+          @hour += 12 if @hour < 12
+          @ambiguous = false
+        end
+        @hour += 12 if @ambiguous and @options[:context] != :none and @hour != 12 and @hour <= @options[:ambiguous_time_range]
+      elsif @time_special
+        if @time_special == :now
+          set_time
+        else
+          @hour = Time::SPECIAL[@time_special].begin
+        end
+      else
+        @hour = @local_date.hour
+      end
+      @ambiguous = false
+      @minute ||= @second ? @local_date.minute : 0
+      @second ||= 0
+      @second += @subsecond if @subsecond
+      @subsecond = 0
+      @normalized = true
+    end
+
+    def is_valid?
+      normalize!
+      true
+    end
+
+    def get_end
+      hour = @hour
+      minute = @minute
+      second = @second
+      case @precision
+      when :hour
+        hour += 1
+      when :minute
+        hour, minute = Time::add_minute(hour, minute)
+      when :second
+        minute, second = Time::add_second(minute, second)
+      when :subsecond
+        minute, second = Time::add_second(minute, second, 1.0 / @subsecond_size)
+      when :time_special
+        if @time_special != :now
+          hour = Time::SPECIAL[@time_special].end
+          minute = second = 0
+        end
+      else
+        # BUG! Should never happen
+        raise "Uknown precision #{@precision.inspect}"
+      end
+      [hour, minute, second]
+    end
+
+    def to_s
+      "hour #{@hour.inspect}, minute #{@minute.inspect}, second #{@second.inspect}, subsecond #{@subsecond.inspect}, time special #{time_special.inspect}, day portion #{@day_portion.inspect}, precision #{@precision.inspect}, ambiguous #{ambiguous.inspect}"
+    end
+
+    protected
+
+    def set_time
+      @hour, @minute, @second = local_time
+    end
+
+    include TimeHandlers
+
+  end
+end

data/lib/chronic/objects/time_zone_object.rb

@@ -0,0 +1,27 @@
+require 'chronic/handlers/time_zone'
+
+module Chronic
+  class TimeZoneObject < HandlerObject
+    include TimeZoneStructure
+
+    def initialize(tokens, token_index, definitions, local_date, options)
+      super
+      match(tokens, @index, definitions)
+    end
+
+    def normalize!
+      return if @normalized
+      @offset = to_offset
+      @normalized = true
+    end
+
+    def is_valid?
+      true
+    end
+
+    protected
+
+    include TimeZoneHandlers
+
+  end
+end

data/lib/chronic/parser.rb

@@ -0,0 +1,154 @@
+require 'chronic/dictionary'
+
+module Chronic
+  class Parser
+
+    # Hash of default configuration options.
+    DEFAULT_OPTIONS = {
+      :context => :future,
+      :now => nil,
+      :hours24 => nil,
+      :week_start => :sunday,
+      :guess => true,
+      :ambiguous_time_range => 6,
+      :endian_precedence    => [:middle, :little],
+      :ambiguous_year_future_bias => 50
+    }
+
+    attr_accessor :now
+    attr_reader :options
+
+    # options - An optional Hash of configuration options:
+    #        :context - If your string represents a birthday, you can set
+    #                   this value to :past and if an ambiguous string is
+    #                   given, it will assume it is in the past.
+    #        :now - Time, all computations will be based off of time
+    #               instead of Time.now.
+    #        :hours24 - Time will be parsed as it would be 24 hour clock.
+    #        :week_start - By default, the parser assesses weeks start on
+    #                  sunday but you can change this value to :monday if
+    #                  needed.
+    #        :guess - By default the parser will guess a single point in time
+    #                 for the given date or time. If you'd rather have the
+    #                 entire time span returned, set this to false
+    #                 and a Chronic::Span will be returned. Setting :guess to :end
+    #                 will return last time from Span, to :middle for middle (same as just true)
+    #                 and :begin for first time from span.
+    #        :ambiguous_time_range - If an Integer is given, ambiguous times
+    #                  (like 5:00) will be assumed to be within the range of
+    #                  that time in the AM to that time in the PM. For
+    #                  example, if you set it to `7`, then the parser will
+    #                  look for the time between 7am and 7pm. In the case of
+    #                  5:00, it would assume that means 5:00pm. If `:none`
+    #                  is given, no assumption will be made, and the first
+    #                  matching instance of that time will be used.
+    #        :endian_precedence - By default, Chronic will parse "03/04/2011"
+    #                 as the fourth day of the third month. Alternatively you
+    #                 can tell Chronic to parse this as the third day of the
+    #                 fourth month by setting this to [:little, :middle].
+    #        :ambiguous_year_future_bias - When parsing two digit years
+    #                 (ie 79) unlike Rubys Time class, Chronic will attempt
+    #                 to assume the full year using this figure. Chronic will
+    #                 look x amount of years into the future and past. If the
+    #                 two digit year is `now + x years` it's assumed to be the
+    #                 future, `now - x years` is assumed to be the past.
+    def initialize(options = {})
+      validate_options!(options)
+      @options = DEFAULT_OPTIONS.merge(options)
+      @now = options[:now] || Chronic.time_class.now
+    end
+
+    # Parse "text" with the given options
+    # Returns either a Time or Chronic::Span, depending on the value of options[:guess]
+    def parse(text)
+      text = pre_proccess(text)
+      text = pre_normalize(text)
+      puts text.inspect if Chronic.debug
+
+      tokens = Tokenizer::tokenize(' ' + text + ' ')
+      tag(tokens, options)
+
+      puts "+#{'-' * 51}\n| #{tokens}\n+#{'-' * 51}" if Chronic.debug
+
+      token_group = TokenGroup.new(tokens, definitions(options), @now, options)
+      span = token_group.to_span
+
+      guess(span, options[:guess]) if span
+    end
+
+    # Replace any whitespace characters to single space
+    def pre_proccess(text)
+      text.to_s.strip.gsub(/[[:space:]]+/, ' ').gsub(/\s{2,}/, ' ')
+    end
+
+    # Clean up the specified text ready for parsing.
+    #
+    # Clean up the string, convert number words to numbers
+    # (three => 3), and convert ordinal words to numeric
+    # ordinals (third => 3rd)
+    #
+    # text - The String text to normalize.
+    #
+    # Returns a new String ready for Chronic to parse.
+    def pre_normalize(text)
+      text.gsub!(/\b(quarters?)\b/, '<=\1=>') # workaround for Numerizer
+      text.gsub!(/\b\s+third\b/, ' 3rd')
+      text.gsub!(/\b\s+fourth\b/, ' 4th')
+      text = Numerizer.numerize(text)
+      text.gsub!(/<=(quarters?)=>/, '\1')
+      text
+    end
+
+    # Guess a specific time within the given span.
+    #
+    # span - The Chronic::Span object to calcuate a guess from.
+    #
+    # Returns a new Time object.
+    def guess(span, mode = :middle)
+      return span if not mode
+      return span.begin + span.width / 2 if span.width > 1 and (mode == true or mode == :middle)
+      return span.end if mode == :end
+      span.begin
+    end
+
+    # List of Handler definitions. See Chronic.parse for a list of options this
+    # method accepts.
+    #
+    # options - An optional Hash of configuration options.
+    #
+    # Returns a Hash of Handler definitions.
+    def definitions(options = {})
+      SpanDictionary.new(options).definitions
+    end
+
+    private
+
+
+    def validate_options!(options)
+      given = options.keys.map(&:to_s).sort
+      allowed = DEFAULT_OPTIONS.keys.map(&:to_s).sort
+      non_permitted = given - allowed
+      raise ArgumentError, "Unsupported option(s): #{non_permitted.join(', ')}" if non_permitted.any?
+    end
+
+    def tag(tokens, options)
+      [DayName, MonthName, SeasonName, DaySpecial, TimeSpecial, DayPortion, Grabber, Pointer, Rational, Keyword, Separator, Scalar, Ordinal, Sign, Unit, TimeZoneTag].each do |tok|
+        tok.scan(tokens, options)
+      end
+      previous = nil
+      tokens.select! do |token|
+        if token.tagged?
+          if !previous or !token.tags.first.kind_of?(Separator) or token.tags.first.class != previous.class
+            previous = token.tags.first
+            true
+          else
+            false
+          end
+        else
+          false
+        end
+      end
+    end
+
+  end
+end