Hokkaido 0.0.3 → 0.0.4

data/chronic/lib/chronic/repeaters/repeater_weekday.rb

@@ -0,0 +1,85 @@
+module Chronic
+  class RepeaterWeekday < Repeater #:nodoc:
+    DAY_SECONDS = 86400 # (24 * 60 * 60)
+    DAYS = {
+      :sunday => 0,
+      :monday => 1,
+      :tuesday => 2,
+      :wednesday => 3,
+      :thursday => 4,
+      :friday => 5,
+      :saturday => 6
+    }
+
+    def initialize(type)
+      super
+    end
+
+    def next(pointer)
+      super
+
+      direction = pointer == :future ? 1 : -1
+
+      if !@current_weekday_start
+        @current_weekday_start = Chronic.construct(@now.year, @now.month, @now.day)
+        @current_weekday_start += direction * DAY_SECONDS
+
+        until is_weekday?(@current_weekday_start.wday)
+          @current_weekday_start += direction * DAY_SECONDS
+        end
+      else
+        loop do
+          @current_weekday_start += direction * DAY_SECONDS
+          break if is_weekday?(@current_weekday_start.wday)
+        end
+      end
+
+      Span.new(@current_weekday_start, @current_weekday_start + DAY_SECONDS)
+    end
+
+    def this(pointer = :future)
+      super
+
+      case pointer
+      when :past
+        self.next(:past)
+      when :future, :none
+        self.next(:future)
+      end
+    end
+
+    def offset(span, amount, pointer)
+      direction = pointer == :future ? 1 : -1
+
+      num_weekdays_passed = 0; offset = 0
+      until num_weekdays_passed == amount
+        offset += direction * DAY_SECONDS
+        num_weekdays_passed += 1 if is_weekday?((span.begin+offset).wday)
+      end
+
+      span + offset
+    end
+
+    def width
+      DAY_SECONDS
+    end
+
+    def to_s
+      super << '-weekday'
+    end
+
+    private
+
+    def is_weekend?(day)
+      day == symbol_to_number(:saturday) || day == symbol_to_number(:sunday)
+    end
+
+    def is_weekday?(day)
+      !is_weekend?(day)
+    end
+
+    def symbol_to_number(sym)
+      DAYS[sym] || raise("Invalid symbol specified")
+    end
+  end
+end

data/chronic/lib/chronic/repeaters/repeater_weekend.rb

@@ -0,0 +1,66 @@
+module Chronic
+  class RepeaterWeekend < Repeater #:nodoc:
+    WEEKEND_SECONDS = 172_800 # (2 * 24 * 60 * 60)
+
+    def initialize(type)
+      super
+    end
+
+    def next(pointer)
+      super
+
+      if !@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/chronic/lib/chronic/repeaters/repeater_year.rb

@@ -0,0 +1,77 @@
+module Chronic
+  class RepeaterYear < Repeater #:nodoc:
+    YEAR_SECONDS =  31536000  # 365 * 24 * 60 * 60
+
+    def initialize(type)
+      super
+    end
+
+    def next(pointer)
+      super
+
+      if !@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/chronic/lib/chronic/scalar.rb

@@ -0,0 +1,116 @@
+module Chronic
+  class Scalar < Tag
+    DAY_PORTIONS = %w( am pm morning afternoon evening night )
+
+    # Scan an Array of Token objects and apply any necessary Scalar
+    # 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 t = scan_for_scalars(tokens[i], tokens[i + 1]) then tokens[i].tag(t) end
+        if t = scan_for_days(tokens[i], tokens[i + 1]) then tokens[i].tag(t) end
+        if t = scan_for_months(tokens[i], tokens[i + 1]) then tokens[i].tag(t) end
+        if t = scan_for_years(tokens[i], tokens[i + 1], options) then tokens[i].tag(t) end
+      end
+    end
+
+    # token - The Token object we want to scan.
+    # post_token - The next Token object.
+    #
+    # Returns a new Scalar object.
+    def self.scan_for_scalars(token, post_token)
+      if token.word =~ /^\d*$/
+        unless post_token && DAY_PORTIONS.include?(post_token.word)
+          return Scalar.new(token.word.to_i)
+        end
+      end
+    end
+
+    # token - The Token object we want to scan.
+    # post_token - The next Token object.
+    #
+    # Returns a new Scalar object.
+    def self.scan_for_days(token, post_token)
+      if token.word =~ /^\d\d?$/
+        toi = token.word.to_i
+        unless toi > 31 || toi < 1 || (post_token && DAY_PORTIONS.include?(post_token.word))
+          return ScalarDay.new(toi)
+        end
+      end
+    end
+
+    # token - The Token object we want to scan.
+    # post_token - The next Token object.
+    #
+    # Returns a new Scalar object.
+    def self.scan_for_months(token, post_token)
+      if token.word =~ /^\d\d?$/
+        toi = token.word.to_i
+        unless toi > 12 || toi < 1 || (post_token && DAY_PORTIONS.include?(post_token.word))
+          return ScalarMonth.new(toi)
+        end
+      end
+    end
+
+    # token - The Token object we want to scan.
+    # post_token - The next Token object.
+    # options - The Hash of options specified in Chronic::parse.
+    #
+    # Returns a new Scalar object.
+    def self.scan_for_years(token, post_token, options)
+      if token.word =~ /^([1-9]\d)?\d\d?$/
+        unless post_token && DAY_PORTIONS.include?(post_token.word)
+          year = make_year(token.word.to_i, options[:ambiguous_year_future_bias])
+          return ScalarYear.new(year.to_i)
+        end
+      end
+    end
+
+    # Build a year from a 2 digit suffix.
+    #
+    # year - The two digit Integer year to build from.
+    # bias - The Integer amount of future years to bias.
+    #
+    # Examples:
+    #
+    #   make_year(96, 50) #=> 1996
+    #   make_year(79, 20) #=> 2079
+    #   make_year(00, 50) #=> 2000
+    #
+    # Returns The Integer 4 digit year.
+    def self.make_year(year, bias)
+      return year if year.to_s.size > 2
+      start_year = Chronic.time_class.now.year - bias
+      century = (start_year / 100) * 100
+      full_year = century + year
+      full_year += 100 if full_year < start_year
+      full_year
+    end
+
+    def to_s
+      'scalar'
+    end
+  end
+
+  class ScalarDay < Scalar #:nodoc:
+    def to_s
+      super << '-day-' << @type.to_s
+    end
+  end
+
+  class ScalarMonth < Scalar #:nodoc:
+    def to_s
+      super << '-month-' << @type.to_s
+    end
+  end
+
+  class ScalarYear < Scalar #:nodoc:
+    def to_s
+      super << '-year-' << @type.to_s
+    end
+  end
+end

data/chronic/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/chronic/lib/chronic/separator.rb

@@ -0,0 +1,94 @@
+module Chronic
+  class Separator < Tag
+
+    # 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_slash_or_dash(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
+      end
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeparatorComma object.
+    def self.scan_for_commas(token)
+      scan_for token, SeparatorComma, { /^,$/ => :comma }
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeparatorSlashOrDash object.
+    def self.scan_for_slash_or_dash(token)
+      scan_for token, SeparatorSlashOrDash,
+      {
+        /^-$/ => :dash,
+        /^\/$/ => :slash
+      }
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeparatorAt object.
+    def self.scan_for_at(token)
+      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)
+      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
+
+    def to_s
+      'separator'
+    end
+  end
+
+  class SeparatorComma < Separator #:nodoc:
+    def to_s
+      super << '-comma'
+    end
+  end
+
+  class SeparatorSlashOrDash < Separator #:nodoc:
+    def to_s
+      super << '-slashordash-' << @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
+
+  class SeparatorOn < Separator #:nodoc:
+    def to_s
+      super << '-on'
+    end
+  end
+end

data/chronic/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? unless RUBY_VERSION =~ /^1.9/
+
+  end
+end

data/chronic/lib/chronic/tag.rb

@@ -0,0 +1,36 @@
+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)
+      @type = type
+    end
+
+    # time - Set the start Time for this Tag.
+    def start=(time)
+      @now = time
+    end
+
+    class << self
+      private
+
+      def scan_for(token, klass, items={})
+        case items
+        when Regexp
+          return klass.new(token.word) if items =~ token.word
+        when Hash
+          items.each do |item, symbol|
+            return klass.new(symbol) if item =~ token.word
+          end
+        end
+        nil
+      end
+
+    end
+
+  end
+end

data/chronic/lib/chronic/time_zone.rb

@@ -0,0 +1,32 @@
+module Chronic
+  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
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new Pointer object.
+    def self.scan_for_all(token)
+      scan_for token, self,
+      {
+        /[PMCE][DS]T|UTC/i => :tz,
+        /(tzminus)?\d{2}:?\d{2}/ => :tz
+      }
+    end
+
+    def to_s
+      'timezone'
+    end
+  end
+end

data/chronic/lib/chronic/token.rb

@@ -0,0 +1,47 @@
+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
+  end
+end