gitlab-chronic 0.10.3

data/lib/chronic/tags/scalar.rb

@@ -0,0 +1,89 @@
+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|
+        token = tokens[i]
+        post_token = tokens[i + 1]
+        if token.word =~ /^\d+$/
+            width = token.word.length
+            scalar = token.word.to_i
+            token.tag(Scalar.new(scalar, width))
+            token.tag(ScalarWide.new(token.word, width)) if width == 4
+            token.tag(ScalarSubsecond.new(scalar, width)) if Chronic::Time::could_be_subsecond?(scalar, width)
+            token.tag(ScalarSecond.new(scalar, width)) if Chronic::Time::could_be_second?(scalar, width)
+            token.tag(ScalarMinute.new(scalar, width)) if Chronic::Time::could_be_minute?(scalar, width)
+            token.tag(ScalarHour.new(scalar, width)) if Chronic::Time::could_be_hour?(scalar, width, options[:hours24] == false)
+            unless post_token and DAY_PORTIONS.include?(post_token.word)
+              token.tag(ScalarDay.new(scalar, width)) if Chronic::Date::could_be_day?(scalar, width)
+              token.tag(ScalarMonth.new(scalar, width)) if Chronic::Date::could_be_month?(scalar, width)
+              if Chronic::Date::could_be_year?(scalar, width)
+                year = Chronic::Date::make_year(scalar, options[:ambiguous_year_future_bias])
+                token.tag(ScalarYear.new(year.to_i, width))
+              end
+          end
+        end
+      end
+    end
+
+    def to_s
+      'scalar'
+    end
+  end
+
+  class ScalarWide < Scalar #:nodoc:
+    def to_s
+      super << '-wide-' << @type.to_s
+    end
+  end
+
+  class ScalarSubsecond < Scalar #:nodoc:
+    def to_s
+      super << '-subsecond-' << @type.to_s
+    end
+  end
+
+  class ScalarSecond < Scalar #:nodoc:
+    def to_s
+      super << '-second-' << @type.to_s
+    end
+  end
+
+  class ScalarMinute < Scalar #:nodoc:
+    def to_s
+      super << '-minute-' << @type.to_s
+    end
+  end
+
+  class ScalarHour < Scalar #:nodoc:
+    def to_s
+      super << '-hour-' << @type.to_s
+    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/lib/chronic/tags/separator.rb

@@ -0,0 +1,123 @@
+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|
+        token.tag scan_for(token, SeparatorComma, { ','.to_sym => :comma })
+        token.tag scan_for(token, SeparatorDot, { '.'.to_sym => :dot })
+        token.tag scan_for(token, SeparatorColon, { ':'.to_sym => :colon })
+        token.tag scan_for(token, SeparatorSpace, { ' '.to_sym => :space })
+        token.tag scan_for(token, SeparatorSlash, { '/'.to_sym => :slash })
+        token.tag scan_for(token, SeparatorDash, { :- => :dash })
+        token.tag scan_for(token, SeparatorAt, { /^(at|@)$/i => :at })
+        token.tag scan_for(token, SeparatorIn, { 'in' => :in })
+        token.tag scan_for(token, SeparatorOn, { 'on' => :on })
+        token.tag scan_for(token, SeparatorAnd, { 'and' => :and })
+        token.tag scan_for(token, SeparatorT, { :T => :T })
+        token.tag scan_for(token, SeparatorW, { :W => :W })
+        token.tag scan_for_quote(token)
+      end
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeparatorQuote object.
+    def self.scan_for_quote(token)
+      scan_for token, SeparatorQuote,
+      {
+        "'".to_sym => :single_quote,
+        '"'.to_sym => :double_quote
+      }
+    end
+
+    def to_s
+      'separator'
+    end
+  end
+
+  class SeparatorComma < Separator #:nodoc:
+    def to_s
+      super << '-comma'
+    end
+  end
+
+  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 << '-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
+
+  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/tags/sign.rb

@@ -0,0 +1,35 @@
+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|
+        token.tag scan_for(token, SignPlus, { :+ => :plus })
+        token.tag scan_for(token, SignMinus, { :- => :minus })
+      end
+    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/tags/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|
+        token.tag scan_for_all(token)
+      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/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, width = nil, hours12 = false)
+      hour >= 0 && hour <= (hours12 ? 12 : 24) && (width.nil? || width > 0)
+    end
+
+    # Checks if given number could be minute
+    def self.could_be_minute?(minute, width = nil)
+      minute >= 0 && minute <= 60 && (width.nil? || width <= 2)
+    end
+
+    # Checks if given number could be second
+    def self.could_be_second?(second, width = nil)
+      second >= 0 && second <= 60 && (width.nil? || width <= 2)
+    end
+
+    # Checks if given number could be subsecond
+    def self.could_be_subsecond?(subsecond, width = nil)
+      subsecond >= 0 && subsecond <= 999999 && (width.nil? || width > 0)
+    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/token.rb

@@ -0,0 +1,61 @@
+module Chronic
+  class Token
+
+    attr_accessor :word
+    attr_accessor :tags
+
+    attr_reader :text
+    attr_reader :position
+
+    def initialize(word, text = nil, position = 0)
+      @word = word
+      @tags = []
+      @text = text
+      @position = position
+    end
+
+    def ==(token)
+      token.word == @word.downcase
+    end
+
+    # Tag this token with the specified tag.
+    #
+    # new_tag - The new Tag object.
+    #
+    # Returns nothing.
+    def tag(new_tag)
+      @tags << new_tag if 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

data/lib/chronic/tokenizer.rb

@@ -0,0 +1,38 @@
+module Chronic
+  module Tokenizer
+    def self.char_type(char)
+      case char
+      when '.'
+        :period
+      when /[[:alpha:]]/
+        :letter
+      when /[[:digit:]]/
+        :digit
+      when /[[:space:]]/
+        :space
+      when /[[:punct:]]/
+        :punct
+      else
+        :other
+      end
+    end
+
+    # Proccess text to tokens
+    def self.tokenize(text)
+      tokens = []
+      index = 0
+      previos_index = 0
+      text.each_char do |char|
+        type = char_type(char)
+        if type == :space
+          tokens << Token.new(text[previos_index...index], text, previos_index)
+          previos_index = index+1
+        end
+        index += 1
+      end
+      tokens << Token.new(text[previos_index...index], text, previos_index)
+      tokens
+    end
+
+  end
+end

data/lib/chronic/version.rb

@@ -0,0 +1,3 @@
+module Chronic
+  VERSION = '0.10.3'
+end

data/test/helper.rb

@@ -0,0 +1,12 @@
+unless defined? Chronic
+  $:.unshift File.expand_path('../../lib', __FILE__)
+  require 'chronic'
+end
+
+require 'minitest/autorun'
+
+class TestCase < MiniTest::Test
+  def self.test(name, &block)
+    define_method("test_#{name.gsub(/\W/, '_')}", &block) if block
+  end
+end

data/test/test_chronic.rb

@@ -0,0 +1,203 @@
+require 'helper'
+
+class TestChronic < TestCase
+
+  def setup
+    # Wed Aug 16 14:00:00 UTC 2006
+    @now = Time.local(2006, 8, 16, 14, 0, 0, 0)
+  end
+
+  def test_pre_normalize
+    assert_equal Chronic::Parser.new.pre_normalize('12:55 pm'), Chronic::Parser.new.pre_normalize('12.55 pm')
+  end
+
+  def test_pre_normalize_numerized_string
+    string = 'two and a half years'
+    assert_equal Numerizer.numerize(string), Chronic::Parser.new.pre_normalize(string)
+  end
+
+  def test_post_normalize_am_pm_aliases
+    # affect wanted patterns
+
+    tokens = [Chronic::Token.new("5:00"), Chronic::Token.new("morning")]
+    tokens[0].tag(Chronic::RepeaterTime.new("5:00"))
+    tokens[1].tag(Chronic::RepeaterDayPortion.new(:morning))
+
+    assert_equal :morning, tokens[1].tags[0].type
+
+    tokens = Chronic::Handlers.dealias_and_disambiguate_times(tokens, {})
+
+    assert_equal :am, tokens[1].tags[0].type
+    assert_equal 2, tokens.size
+
+    # don't affect unwanted patterns
+
+    tokens = [Chronic::Token.new("friday"), Chronic::Token.new("morning")]
+    tokens[0].tag(Chronic::RepeaterDayName.new(:friday))
+    tokens[1].tag(Chronic::RepeaterDayPortion.new(:morning))
+
+    assert_equal :morning, tokens[1].tags[0].type
+
+    tokens = Chronic::Handlers.dealias_and_disambiguate_times(tokens, {})
+
+    assert_equal :morning, tokens[1].tags[0].type
+    assert_equal 2, tokens.size
+  end
+
+  def test_guess
+    span = Chronic::Span.new(Time.local(2006, 8, 16, 0), Time.local(2006, 8, 17, 0))
+    assert_equal Time.local(2006, 8, 16, 12), Chronic::Parser.new.guess(span)
+
+    span = Chronic::Span.new(Time.local(2006, 8, 16, 0), Time.local(2006, 8, 17, 0, 0, 1))
+    assert_equal Time.local(2006, 8, 16, 12), Chronic::Parser.new.guess(span)
+
+    span = Chronic::Span.new(Time.local(2006, 11), Time.local(2006, 12))
+    assert_equal Time.local(2006, 11, 16), Chronic::Parser.new.guess(span)
+  end
+
+  def test_endian_definitions
+    # middle, little
+    endians = [
+      Chronic::Handler.new([:scalar_month, [:separator_slash, :separator_dash], :scalar_day, [:separator_slash, :separator_dash], :scalar_year, :separator_at?, 'time?'], :handle_sm_sd_sy),
+      Chronic::Handler.new([:scalar_month, [:separator_slash, :separator_dash], :scalar_day, :separator_at?, 'time?'], :handle_sm_sd),
+      Chronic::Handler.new([:scalar_day, [:separator_slash, :separator_dash], :scalar_month, :separator_at?, 'time?'], :handle_sd_sm),
+      Chronic::Handler.new([:scalar_day, [:separator_slash, :separator_dash], :scalar_month, [:separator_slash, :separator_dash], :scalar_year, :separator_at?, 'time?'], :handle_sd_sm_sy),
+      Chronic::Handler.new([:scalar_day, :repeater_month_name, :scalar_year, :separator_at?, 'time?'], :handle_sd_rmn_sy)
+    ]
+
+    assert_equal endians, Chronic::SpanDictionary.new.definitions[:endian]
+
+    defs = Chronic::SpanDictionary.new(:endian_precedence => :little).definitions
+    assert_equal endians.reverse, defs[:endian]
+
+    defs = Chronic::SpanDictionary.new(:endian_precedence => [:little, :middle]).definitions
+    assert_equal endians.reverse, defs[:endian]
+
+    assert_raises(ArgumentError) do
+      Chronic::SpanDictionary.new(:endian_precedence => :invalid).definitions
+    end
+  end
+
+  def test_debug
+    require 'stringio'
+    $stdout = StringIO.new
+    Chronic.debug = true
+
+    Chronic.parse 'now'
+    assert $stdout.string.include?('this(grabber-this)')
+  ensure
+    $stdout = STDOUT
+    Chronic.debug = false
+  end
+
+  # Chronic.construct
+
+  def test_normal
+    assert_equal Time.local(2006, 1, 2, 0, 0, 0), Chronic.construct(2006, 1, 2, 0, 0, 0)
+    assert_equal Time.local(2006, 1, 2, 3, 0, 0), Chronic.construct(2006, 1, 2, 3, 0, 0)
+    assert_equal Time.local(2006, 1, 2, 3, 4, 0), Chronic.construct(2006, 1, 2, 3, 4, 0)
+    assert_equal Time.local(2006, 1, 2, 3, 4, 5), Chronic.construct(2006, 1, 2, 3, 4, 5)
+  end
+
+  def test_second_overflow
+    assert_equal Time.local(2006, 1, 1, 0, 1, 30), Chronic.construct(2006, 1, 1, 0, 0, 90)
+    assert_equal Time.local(2006, 1, 1, 0, 5, 0), Chronic.construct(2006, 1, 1, 0, 0, 300)
+  end
+
+  def test_minute_overflow
+    assert_equal Time.local(2006, 1, 1, 1, 30), Chronic.construct(2006, 1, 1, 0, 90)
+    assert_equal Time.local(2006, 1, 1, 5), Chronic.construct(2006, 1, 1, 0, 300)
+  end
+
+  def test_hour_overflow
+    assert_equal Time.local(2006, 1, 2, 12), Chronic.construct(2006, 1, 1, 36)
+    assert_equal Time.local(2006, 1, 7), Chronic.construct(2006, 1, 1, 144)
+  end
+
+  def test_day_overflow
+    assert_equal Time.local(2006, 2, 1), Chronic.construct(2006, 1, 32)
+    assert_equal Time.local(2006, 3, 5), Chronic.construct(2006, 2, 33)
+    assert_equal Time.local(2004, 3, 4), Chronic.construct(2004, 2, 33)
+    assert_equal Time.local(2000, 3, 4), Chronic.construct(2000, 2, 33)
+
+    assert_raises(RuntimeError) do
+      Chronic.construct(2006, 1, 57)
+    end
+  end
+
+  def test_month_overflow
+    assert_equal Time.local(2006, 1), Chronic.construct(2005, 13)
+    assert_equal Time.local(2005, 12), Chronic.construct(2000, 72)
+  end
+
+  def test_time
+    org = Chronic.time_class
+    begin
+      Chronic.time_class = ::Time
+      assert_equal ::Time.new(2013, 8, 27, 20, 30, 40, '+05:30'), Chronic.construct(2013, 8, 27, 20, 30, 40, '+05:30')
+      assert_equal ::Time.new(2013, 8, 27, 20, 30, 40, '-08:00'), Chronic.construct(2013, 8, 27, 20, 30, 40, -28800)
+    ensure
+      Chronic.time_class = org
+    end
+  end
+
+  def test_date
+    org = Chronic.time_class
+    begin
+      Chronic.time_class = ::Date
+      assert_equal Date.new(2013, 8, 27), Chronic.construct(2013, 8, 27)
+    ensure
+      Chronic.time_class = org
+    end
+  end
+
+  def test_datetime
+    org = Chronic.time_class
+    begin
+      Chronic.time_class = ::DateTime
+      assert_equal DateTime.new(2013, 8, 27, 20, 30, 40, '+05:30'), Chronic.construct(2013, 8, 27, 20, 30, 40, '+05:30')
+      assert_equal DateTime.new(2013, 8, 27, 20, 30, 40, '-08:00'), Chronic.construct(2013, 8, 27, 20, 30, 40, -28800)
+    ensure
+      Chronic.time_class = org
+    end
+  end
+
+  def test_valid_options
+    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
+    }
+    refute_nil Chronic.parse('now', options)
+  end
+
+  def test_invalid_options
+    assert_raises(ArgumentError) { Chronic.parse('now', foo: 'boo') }
+    assert_raises(ArgumentError) { Chronic.parse('now', time_class: Time) }
+  end
+
+  def test_activesupport
+=begin
+    # ActiveSupport needs MiniTest '~> 4.2' which conflicts with '~> 5.0'
+    require 'active_support/time'
+    org = Chronic.time_class
+    org_zone = ::Time.zone
+    begin
+      ::Time.zone = "Tokyo"
+      Chronic.time_class = ::Time.zone
+      assert_equal Time.new(2013, 8, 27, 20, 30, 40, '+09:00'), Chronic.construct(2013, 8, 27, 20, 30, 40)
+      ::Time.zone = "Indiana (East)"
+      Chronic.time_class = ::Time.zone
+      assert_equal Time.new(2013, 8, 27, 20, 30, 40, -14400), Chronic.construct(2013, 8, 27, 20, 30, 40)
+    ensure
+      Chronic.time_class = org
+      ::Time.zone = org_zone
+    end
+=end
+  end
+end