gitlab-chronic 0.10.3

data/Rakefile

@@ -0,0 +1,68 @@
+$:.unshift File.expand_path('../lib', __FILE__)
+require 'chronic/version'
+
+def version
+  Chronic::VERSION
+end
+
+def do_test
+  require 'chronic'
+  $:.unshift './test'
+  Dir.glob('test/test_*.rb').each { |t| require File.basename(t) }
+end
+
+def open_command
+  case RUBY_PLATFORM
+  when /mswin|msys|mingw|cygwin|bccwin|wince|emc/
+    'start'
+  when /darwin|mac os/
+    'open'
+  else
+    'xdg-open'
+  end
+end
+
+desc 'Run tests'
+task :test do
+  do_test
+end
+
+desc 'Generate SimpleCov test coverage and open in your browser'
+task :coverage do
+  require 'simplecov'
+  FileUtils.rm_rf('./coverage')
+  SimpleCov.command_name 'Unit Tests'
+  SimpleCov.at_exit do
+    SimpleCov.result.format!
+    sh "#{open_command} #{SimpleCov.coverage_path}/index.html"
+  end
+  SimpleCov.start
+  do_test
+end
+
+desc 'Open an irb session preloaded with this library'
+task :console do
+  sh 'irb -Ilib -rchronic'
+end
+
+desc "Release Chronic version #{version}"
+task :release => :build do
+  unless `git branch` =~ /^\* master$/
+    puts "You must be on the master branch to release!"
+    exit!
+  end
+  sh "git commit --allow-empty -a -m 'Release #{version}'"
+  sh "git tag v#{version}"
+  sh "git push origin master"
+  sh "git push origin v#{version}"
+  sh "gem push pkg/chronic-#{version}.gem"
+end
+
+desc 'Build a gem from the gemspec'
+task :build do
+  FileUtils.mkdir_p 'pkg'
+  sh 'gem build chronic.gemspec'
+  FileUtils.mv("./gitlab-chronic-#{version}.gem", "pkg")
+end
+
+task :default => :test

data/chronic.gemspec

@@ -0,0 +1,25 @@
+$:.unshift File.expand_path('../lib', __FILE__)
+require 'chronic/version'
+
+Gem::Specification.new do |s|
+  s.name = 'gitlab-chronic'
+  s.version = Chronic::VERSION
+  s.rubyforge_project = 'chronic'
+  s.summary     = 'Natural language date/time parsing.'
+  s.description = 'Chronic is a natural language date/time parser written in pure Ruby.'
+  s.authors  = ['Tom Preston-Werner', 'Lee Jarvis']
+  s.email    = ['tom@mojombo.com', 'ljjarvis@gmail.com']
+  s.homepage = 'https://gitlab.com/gitlab-org/gitlab-chronic'
+  s.license = 'MIT'
+  s.rdoc_options = ['--charset=UTF-8']
+  s.extra_rdoc_files = %w[README.md HISTORY.md LICENSE]
+  s.files = `git ls-files`.split($/)
+  s.test_files = `git ls-files -- test`.split($/)
+
+  s.add_runtime_dependency 'numerizer', '~> 0.2'
+
+  s.add_development_dependency 'rake', '~> 10'
+  s.add_development_dependency 'simplecov', '~> 0'
+  s.add_development_dependency 'minitest', '~> 5.0'
+  s.add_development_dependency 'activesupport', '~> 4'
+end

data/lib/chronic.rb

@@ -0,0 +1,155 @@
+require 'time'
+require 'date'
+require 'numerizer'
+
+require 'chronic/version'
+
+require 'chronic/parser'
+require 'chronic/date'
+require 'chronic/time'
+
+require 'chronic/handler'
+require 'chronic/handlers'
+require 'chronic/mini_date'
+require 'chronic/span'
+require 'chronic/token'
+require 'chronic/tokenizer'
+require 'chronic/season'
+
+require 'chronic/tag'
+require 'chronic/tags/grabber'
+require 'chronic/tags/ordinal'
+require 'chronic/tags/pointer'
+require 'chronic/tags/scalar'
+require 'chronic/tags/separator'
+require 'chronic/tags/sign'
+require 'chronic/tags/time_zone'
+
+require 'chronic/tags/repeater'
+require 'chronic/repeaters/repeater_year'
+require 'chronic/repeaters/repeater_quarter'
+require 'chronic/repeaters/repeater_quarter_name'
+require 'chronic/repeaters/repeater_season'
+require 'chronic/repeaters/repeater_season_name'
+require 'chronic/repeaters/repeater_month'
+require 'chronic/repeaters/repeater_month_name'
+require 'chronic/repeaters/repeater_fortnight'
+require 'chronic/repeaters/repeater_week'
+require 'chronic/repeaters/repeater_weekend'
+require 'chronic/repeaters/repeater_weekday'
+require 'chronic/repeaters/repeater_day'
+require 'chronic/repeaters/repeater_day_name'
+require 'chronic/repeaters/repeater_day_portion'
+require 'chronic/repeaters/repeater_hour'
+require 'chronic/repeaters/repeater_minute'
+require 'chronic/repeaters/repeater_second'
+require 'chronic/repeaters/repeater_time'
+
+# Parse natural language dates and times into Time or Chronic::Span objects.
+#
+# Examples:
+#
+#   require 'chronic'
+#
+#   Time.now   #=> Sun Aug 27 23:18:25 PDT 2006
+#
+#   Chronic.parse('tomorrow')
+#     #=> Mon Aug 28 12:00:00 PDT 2006
+#
+#   Chronic.parse('monday', :context => :past)
+#     #=> Mon Aug 21 12:00:00 PDT 2006
+module Chronic
+
+  class << self
+
+    # Returns true when debug mode is enabled.
+    attr_accessor :debug
+
+    # Examples:
+    #
+    #   require 'chronic'
+    #   require 'active_support/time'
+    #
+    #   Time.zone = 'UTC'
+    #   Chronic.time_class = Time.zone
+    #   Chronic.parse('June 15 2006 at 5:54 AM')
+    #     # => Thu, 15 Jun 2006 05:45:00 UTC +00:00
+    #
+    # Returns The Time class Chronic uses internally.
+    attr_accessor :time_class
+  end
+
+  self.debug = false
+  self.time_class = ::Time
+
+
+  # Parses a string containing a natural language date or time.
+  #
+  # If the parser can find a date or time, either a Time or Chronic::Span
+  # will be returned (depending on the value of `:guess`). If no
+  # date or time can be found, `nil` will be returned.
+  #
+  # text - The String text to parse.
+  # opts - An optional Hash of configuration options passed to Parser::new.
+  def self.parse(text, options = {})
+    Parser.new(options).parse(text)
+  end
+
+  # Construct a new time object determining possible month overflows
+  # and leap years.
+  #
+  # year   - Integer year.
+  # month  - Integer month.
+  # day    - Integer day.
+  # hour   - Integer hour.
+  # minute - Integer minute.
+  # second - Integer second.
+  #
+  # Returns a new Time object constructed from these params.
+  def self.construct(year, month = 1, day = 1, hour = 0, minute = 0, second = 0, offset = nil)
+    if second >= 60
+      minute += second / 60
+      second = second % 60
+    end
+
+    if minute >= 60
+      hour += minute / 60
+      minute = minute % 60
+    end
+
+    if hour >= 24
+      day += hour / 24
+      hour = hour % 24
+    end
+
+    # determine if there is a day overflow. this is complicated by our crappy calendar
+    # system (non-constant number of days per month)
+    day <= 56 || raise('day must be no more than 56 (makes month resolution easier)')
+    if day > 28 # no month ever has fewer than 28 days, so only do this if necessary
+      days_this_month = ::Date.leap?(year) ? Date::MONTH_DAYS_LEAP[month] : Date::MONTH_DAYS[month]
+      if day > days_this_month
+        month += day / days_this_month
+        day = day % days_this_month
+      end
+    end
+
+    if month > 12
+      if month % 12 == 0
+        year += (month - 12) / 12
+        month = 12
+      else
+        year += month / 12
+        month = month % 12
+      end
+    end
+    if Chronic.time_class.name == 'Date'
+      Chronic.time_class.new(year, month, day)
+    elsif not Chronic.time_class.respond_to?(:new) or (RUBY_VERSION.to_f < 1.9 and Chronic.time_class.name == 'Time')
+      Chronic.time_class.local(year, month, day, hour, minute, second)
+    else
+      offset = Time::normalize_offset(offset) if Chronic.time_class.name == 'DateTime'
+      Chronic.time_class.new(year, month, day, hour, minute, second, offset)
+    end
+  end
+
+end

data/lib/chronic/date.rb

@@ -0,0 +1,81 @@
+module Chronic
+  class Date
+    YEAR_MONTHS = 12
+    MONTH_DAYS        = [nil, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
+    MONTH_DAYS_LEAP   = [nil, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
+    YEAR_SECONDS      = 31_536_000 # 365 * 24 * 60 * 60
+    SEASON_SECONDS    =  7_862_400 #  91 * 24 * 60 * 60
+    MONTH_SECONDS     =  2_592_000 #  30 * 24 * 60 * 60
+    FORTNIGHT_SECONDS =  1_209_600 #  14 * 24 * 60 * 60
+    WEEK_SECONDS      =    604_800 #   7 * 24 * 60 * 60
+    WEEKEND_SECONDS   =    172_800 #   2 * 24 * 60 * 60
+    DAY_SECONDS       =     86_400 #       24 * 60 * 60
+    MONTHS = {
+      :january => 1,
+      :february => 2,
+      :march => 3,
+      :april => 4,
+      :may => 5,
+      :june => 6,
+      :july => 7,
+      :august => 8,
+      :september => 9,
+      :october => 10,
+      :november => 11,
+      :december => 12
+    }
+    DAYS = {
+      :sunday => 0,
+      :monday => 1,
+      :tuesday => 2,
+      :wednesday => 3,
+      :thursday => 4,
+      :friday => 5,
+      :saturday => 6
+    }
+
+    # Checks if given number could be day
+    def self.could_be_day?(day, width = nil)
+      day >= 1 && day <= 31 && (width.nil? || width <= 2)
+    end
+
+    # Checks if given number could be month
+    def self.could_be_month?(month, width = nil)
+      month >= 1 && month <= 12 && (width.nil? || width <= 2)
+    end
+
+    # Checks if given number could be year
+    def self.could_be_year?(year, width = nil)
+      year >= 0 && year <= 9999 && (width.nil? || width == 2 || width == 4)
+    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 self.month_overflow?(year, month, day)
+      if ::Date.leap?(year)
+        day > Date::MONTH_DAYS_LEAP[month]
+      else
+        day > Date::MONTH_DAYS[month]
+      end
+    end
+
+  end
+end

data/lib/chronic/definition.rb

@@ -0,0 +1,128 @@
+require 'chronic/handlers'
+
+module Chronic
+  # SpanDefinitions subclasses return definitions constructed by Handler instances (see handler.rb)
+  # SpanDefinitions subclasses follow a <Type> + Definitions naming pattern
+  # Types of Definitions are collected in Dictionaries (see dictionary.rb)
+  class Definitions
+    attr_reader :options
+
+    def initialize(options = {})
+      @options = options
+    end
+
+    def definitions
+      raise "definitions are set in subclasses of #{self.class}"
+    end
+  end
+
+  class SpanDefinitions < Definitions
+    include Handlers
+  end
+
+  class TimeDefinitions < SpanDefinitions
+    def definitions
+      [
+        Handler.new([:repeater_time, :repeater_day_portion?], nil)
+      ]
+    end
+  end
+
+  class DateDefinitions < SpanDefinitions
+    def definitions
+      [
+        Handler.new([:repeater_day_name, :repeater_month_name, :scalar_day, :repeater_time, [:separator_slash?, :separator_dash?], :time_zone, :scalar_year], :handle_generic),
+        Handler.new([:repeater_day_name, :repeater_month_name, :scalar_day], :handle_rdn_rmn_sd),
+        Handler.new([:repeater_day_name, :repeater_month_name, :scalar_day, :scalar_year], :handle_rdn_rmn_sd_sy),
+        Handler.new([:repeater_day_name, :repeater_month_name, :ordinal_day], :handle_rdn_rmn_od),
+        Handler.new([:repeater_day_name, :repeater_month_name, :ordinal_day, :scalar_year], :handle_rdn_rmn_od_sy),
+        Handler.new([:repeater_day_name, :repeater_month_name, :scalar_day, :separator_at?, 'time?'], :handle_rdn_rmn_sd),
+        Handler.new([:repeater_day_name, :repeater_month_name, :ordinal_day, :separator_at?, 'time?'], :handle_rdn_rmn_od),
+        Handler.new([:repeater_day_name, :ordinal_day, :separator_at?, 'time?'], :handle_rdn_od),
+        Handler.new([:scalar_year, [:separator_slash, :separator_dash], :scalar_month, [:separator_slash, :separator_dash], :scalar_day, :repeater_time, :time_zone], :handle_generic),
+        Handler.new([:ordinal_day], :handle_generic),
+        Handler.new([:repeater_month_name, :scalar_day, :scalar_year], :handle_rmn_sd_sy),
+        Handler.new([:repeater_month_name, :ordinal_day, :scalar_year], :handle_rmn_od_sy),
+        Handler.new([:repeater_month_name, :scalar_day, :scalar_year, :separator_at?, 'time?'], :handle_rmn_sd_sy),
+        Handler.new([:repeater_month_name, :ordinal_day, :scalar_year, :separator_at?, 'time?'], :handle_rmn_od_sy),
+        Handler.new([:repeater_month_name, [:separator_slash?, :separator_dash?], :scalar_day, :separator_at?, 'time?'], :handle_rmn_sd),
+        Handler.new([:repeater_time, :repeater_day_portion?, :separator_on?, :repeater_month_name, :scalar_day], :handle_rmn_sd_on),
+        Handler.new([:repeater_month_name, :ordinal_day, :separator_at?, 'time?'], :handle_rmn_od),
+        Handler.new([:ordinal_day, :repeater_month_name, :scalar_year, :separator_at?, 'time?'], :handle_od_rmn_sy),
+        Handler.new([:ordinal_day, :repeater_month_name, :separator_at?, 'time?'], :handle_od_rmn),
+        Handler.new([:ordinal_day, :grabber?, :repeater_month, :separator_at?, 'time?'], :handle_od_rm),
+        Handler.new([:scalar_year, :repeater_month_name, :ordinal_day], :handle_sy_rmn_od),
+        Handler.new([:repeater_time, :repeater_day_portion?, :separator_on?, :repeater_month_name, :ordinal_day], :handle_rmn_od_on),
+        Handler.new([:repeater_month_name, :scalar_year], :handle_rmn_sy),
+        Handler.new([:repeater_quarter_name, :scalar_year], :handle_rqn_sy),
+        Handler.new([:scalar_year, :repeater_quarter_name], :handle_sy_rqn),
+        Handler.new([:scalar_day, :repeater_month_name, :scalar_year, :separator_at?, 'time?'], :handle_sd_rmn_sy),
+        Handler.new([:scalar_day, [:separator_slash?, :separator_dash?], :repeater_month_name, :separator_at?, 'time?'], :handle_sd_rmn),
+        Handler.new([:scalar_year, [:separator_slash, :separator_dash], :scalar_month, [:separator_slash, :separator_dash], :scalar_day, :separator_at?, 'time?'], :handle_sy_sm_sd),
+        Handler.new([:scalar_year, [:separator_slash, :separator_dash], :scalar_month], :handle_sy_sm),
+        Handler.new([:scalar_month, [:separator_slash, :separator_dash], :scalar_year], :handle_sm_sy),
+        Handler.new([:scalar_day, [:separator_slash, :separator_dash], :repeater_month_name, [:separator_slash, :separator_dash], :scalar_year, :repeater_time?], :handle_sm_rmn_sy),
+        Handler.new([:scalar_year, [:separator_slash, :separator_dash], :scalar_month, [:separator_slash, :separator_dash], :scalar?, :time_zone], :handle_generic),
+      ]
+    end
+  end
+
+  class AnchorDefinitions < SpanDefinitions
+    def definitions
+      [
+        Handler.new([:separator_on?, :grabber?, :repeater, :separator_at?, :repeater?, :repeater?], :handle_r),
+        Handler.new([:grabber?, :repeater, :repeater, :separator?, :repeater?, :repeater?], :handle_r),
+        Handler.new([:repeater, :grabber, :repeater], :handle_r_g_r)
+      ]
+    end
+  end
+
+  class ArrowDefinitions < SpanDefinitions
+    def definitions
+      [
+        Handler.new([:repeater_month_name, :scalar, :repeater, :pointer], :handle_rmn_s_r_p),
+        Handler.new([:scalar, :repeater, :pointer], :handle_s_r_p),
+        Handler.new([:scalar, :repeater, :separator_and?, :scalar, :repeater, :pointer, :separator_at?, 'anchor'], :handle_s_r_a_s_r_p_a),
+        Handler.new([:pointer, :scalar, :repeater], :handle_p_s_r),
+        Handler.new([:scalar, :repeater, :pointer, :separator_at?, 'anchor'], :handle_s_r_p_a)
+      ]
+    end
+  end
+
+  class NarrowDefinitions < SpanDefinitions
+    def definitions
+      [
+        Handler.new([:ordinal, :repeater, :separator_in, :repeater], :handle_o_r_s_r),
+        Handler.new([:ordinal, :repeater, :grabber, :repeater], :handle_o_r_g_r)
+      ]
+    end
+  end
+
+  class EndianDefinitions < SpanDefinitions
+    def definitions
+      prefered_endian
+    end
+
+    def prefered_endian
+      options[:endian_precedence] ||= [:middle, :little]
+
+      definitions = [
+        Handler.new([:scalar_month, [:separator_slash, :separator_dash], :scalar_day, [:separator_slash, :separator_dash], :scalar_year, :separator_at?, 'time?'], :handle_sm_sd_sy),
+        Handler.new([:scalar_month, [:separator_slash, :separator_dash], :scalar_day, :separator_at?, 'time?'], :handle_sm_sd),
+        Handler.new([:scalar_day, [:separator_slash, :separator_dash], :scalar_month, :separator_at?, 'time?'], :handle_sd_sm),
+        Handler.new([:scalar_day, [:separator_slash, :separator_dash], :scalar_month, [:separator_slash, :separator_dash], :scalar_year, :separator_at?, 'time?'], :handle_sd_sm_sy),
+        Handler.new([:scalar_day, :repeater_month_name, :scalar_year, :separator_at?, 'time?'], :handle_sd_rmn_sy)
+      ]
+
+      case endian = Array(options[:endian_precedence]).first
+      when :little
+        definitions.reverse
+      when :middle
+        definitions
+      else
+        raise ArgumentError, "Unknown endian option '#{endian}'"
+      end
+    end
+  end
+
+end