gitlab-chronic 0.10.3

data/lib/chronic/repeaters/repeater_weekend.rb

@@ -0,0 +1,67 @@
+module Chronic
+  class RepeaterWeekend < Repeater #:nodoc:
+    WEEKEND_SECONDS = 172_800 # (2 * 24 * 60 * 60)
+
+    def initialize(type, width = nil, options = {})
+      super
+      @current_week_start = nil
+    end
+
+    def next(pointer)
+      super
+
+      unless @current_week_start
+        case pointer
+        when :future
+          saturday_repeater = RepeaterDayName.new(:saturday)
+          saturday_repeater.start = @now
+          next_saturday_span = saturday_repeater.next(:future)
+          @current_week_start = next_saturday_span.begin
+        when :past
+          saturday_repeater = RepeaterDayName.new(:saturday)
+          saturday_repeater.start = (@now + RepeaterDay::DAY_SECONDS)
+          last_saturday_span = saturday_repeater.next(:past)
+          @current_week_start = last_saturday_span.begin
+        end
+      else
+        direction = pointer == :future ? 1 : -1
+        @current_week_start += direction * RepeaterWeek::WEEK_SECONDS
+      end
+
+      Span.new(@current_week_start, @current_week_start + WEEKEND_SECONDS)
+    end
+
+    def this(pointer = :future)
+      super
+
+      case pointer
+      when :future, :none
+        saturday_repeater = RepeaterDayName.new(:saturday)
+        saturday_repeater.start = @now
+        this_saturday_span = saturday_repeater.this(:future)
+        Span.new(this_saturday_span.begin, this_saturday_span.begin + WEEKEND_SECONDS)
+      when :past
+        saturday_repeater = RepeaterDayName.new(:saturday)
+        saturday_repeater.start = @now
+        last_saturday_span = saturday_repeater.this(:past)
+        Span.new(last_saturday_span.begin, last_saturday_span.begin + WEEKEND_SECONDS)
+      end
+    end
+
+    def offset(span, amount, pointer)
+      direction = pointer == :future ? 1 : -1
+      weekend = RepeaterWeekend.new(:weekend)
+      weekend.start = span.begin
+      start = weekend.next(pointer).begin + (amount - 1) * direction * RepeaterWeek::WEEK_SECONDS
+      Span.new(start, start + (span.end - span.begin))
+    end
+
+    def width
+      WEEKEND_SECONDS
+    end
+
+    def to_s
+      super << '-weekend'
+    end
+  end
+end

data/lib/chronic/repeaters/repeater_year.rb

@@ -0,0 +1,78 @@
+module Chronic
+  class RepeaterYear < Repeater #:nodoc:
+    YEAR_SECONDS =  31536000  # 365 * 24 * 60 * 60
+
+    def initialize(type, width = nil, options = {})
+      super
+      @current_year_start = nil
+    end
+
+    def next(pointer)
+      super
+
+      unless @current_year_start
+        case pointer
+        when :future
+          @current_year_start = Chronic.construct(@now.year + 1)
+        when :past
+          @current_year_start = Chronic.construct(@now.year - 1)
+        end
+      else
+        diff = pointer == :future ? 1 : -1
+        @current_year_start = Chronic.construct(@current_year_start.year + diff)
+      end
+
+      Span.new(@current_year_start, Chronic.construct(@current_year_start.year + 1))
+    end
+
+    def this(pointer = :future)
+      super
+
+      case pointer
+      when :future
+        this_year_start = Chronic.construct(@now.year, @now.month, @now.day + 1)
+        this_year_end = Chronic.construct(@now.year + 1, 1, 1)
+      when :past
+        this_year_start = Chronic.construct(@now.year, 1, 1)
+        this_year_end = Chronic.construct(@now.year, @now.month, @now.day)
+      when :none
+        this_year_start = Chronic.construct(@now.year, 1, 1)
+        this_year_end = Chronic.construct(@now.year + 1, 1, 1)
+      end
+
+      Span.new(this_year_start, this_year_end)
+    end
+
+    def offset(span, amount, pointer)
+      direction = pointer == :future ? 1 : -1
+      new_begin = build_offset_time(span.begin, amount, direction)
+      new_end   = build_offset_time(span.end, amount, direction)
+      Span.new(new_begin, new_end)
+    end
+
+    def width
+      YEAR_SECONDS
+    end
+
+    def to_s
+      super << '-year'
+    end
+
+    private
+
+    def build_offset_time(time, amount, direction)
+      year = time.year + (amount * direction)
+      days = month_days(year, time.month)
+      day = time.day > days ? days : time.day
+      Chronic.construct(year, time.month, day, time.hour, time.min, time.sec)
+    end
+
+    def month_days(year, month)
+      if ::Date.leap?(year)
+        RepeaterMonth::MONTH_DAYS_LEAP[month - 1]
+      else
+        RepeaterMonth::MONTH_DAYS[month - 1]
+      end
+    end
+  end
+end

data/lib/chronic/season.rb

@@ -0,0 +1,26 @@
+module Chronic
+  class Season
+
+    attr_reader :start
+    attr_reader :end
+
+    def initialize(start_date, end_date)
+      @start = start_date
+      @end = end_date
+    end
+
+    def self.find_next_season(season, pointer)
+      lookup = [:spring, :summer, :autumn, :winter]
+      next_season_num = (lookup.index(season) + 1 * pointer) % 4
+      lookup[next_season_num]
+    end
+
+    def self.season_after(season)
+      find_next_season(season, +1)
+    end
+
+    def self.season_before(season)
+      find_next_season(season, -1)
+    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,89 @@
+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
+
+    # time - Set the start Time for this Tag.
+    def start=(time)
+      @now = time
+    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/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/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+)(st|nd|rd|th|\.)$/
+          width = $1.length
+          ordinal = $1.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 ||= {
+        'past' => :past,
+        /^future|in$/i => :future,
+      }
+    end
+
+    def to_s
+      'pointer-' << @type.to_s
+    end
+  end
+end

data/lib/chronic/tags/repeater.rb

@@ -0,0 +1,160 @@
+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|
+        token.tag scan_for_quarter_names(token, options)
+        token.tag scan_for_season_names(token, options)
+        token.tag scan_for_month_names(token, options)
+        token.tag scan_for_day_names(token, options)
+        token.tag scan_for_day_portions(token, options)
+        token.tag scan_for_times(token, options)
+        token.tag scan_for_units(token, options)
+      end
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new Repeater object.
+    def self.scan_for_quarter_names(token, options = {})
+      scan_for token, RepeaterQuarterName,
+      {
+        /^q1$/ => :q1,
+        /^q2$/ => :q2,
+        /^q3$/ => :q3,
+        /^q4$/ => :q4
+      }, options
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new Repeater object.
+    def self.scan_for_season_names(token, options = {})
+      scan_for token, RepeaterSeasonName,
+      {
+        /^springs?$/ => :spring,
+        /^summers?$/ => :summer,
+        /^(autumn)|(fall)s?$/ => :autumn,
+        /^winters?$/ => :winter
+      }, options
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new Repeater object.
+    def self.scan_for_month_names(token, options = {})
+      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
+      }, options
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new Repeater object.
+    def self.scan_for_day_names(token, options = {})
+      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
+      }, options
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new Repeater object.
+    def self.scan_for_day_portions(token, options = {})
+      scan_for token, RepeaterDayPortion,
+      {
+        /^ams?$/ => :am,
+        /^pms?$/ => :pm,
+        /^mornings?$/ => :morning,
+        /^afternoons?$/ => :afternoon,
+        /^evenings?$/ => :evening,
+        /^(night|nite)s?$/ => :night
+      }, options
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new Repeater object.
+    def self.scan_for_times(token, options = {})
+      scan_for token, RepeaterTime, /^\d{1,2}(:?\d{1,2})?([\.:]?\d{1,2}([\.:]\d{1,6})?)?$/, options
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new Repeater object.
+    def self.scan_for_units(token, options = {})
+      {
+        /^years?$/ => :year,
+        /^q$/ => :quarter,
+        /^seasons?$/ => :season,
+        /^months?$/ => :month,
+        /^fortnights?$/ => :fortnight,
+        /^weeks?$/ => :week,
+        /^weekends?$/ => :weekend,
+        /^(week|business)days?$/ => :weekday,
+        /^days?$/ => :day,
+	      /^hrs?$/ => :hour,
+        /^hours?$/ => :hour,
+	      /^mins?$/ => :minute,
+        /^minutes?$/ => :minute,
+	      /^secs?$/ => :second,
+        /^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, nil, options)
+        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