chronic-davispuh 0.10.2.v0.1da32066b3f46f2506b3471e39557497e34afa27

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("./chronic-#{version}.gem", "pkg")
+end
+
+task :default => :test

data/chronic.gemspec

@@ -0,0 +1,27 @@
+$:.unshift File.expand_path('../lib', __FILE__)
+require 'chronic/version'
+
+Gem::Specification.new do |s|
+  s.name = 'chronic-davispuh'
+  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 = 'http://github.com/mojombo/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_runtime_dependency 'tzinfo'
+  s.add_runtime_dependency 'TimezoneParser'
+
+  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,122 @@
+require 'time'
+require 'date'
+require 'numerizer'
+
+require 'chronic/version'
+
+require 'tzinfo'
+require 'timezone_parser'
+
+require 'chronic/parser'
+require 'chronic/date'
+require 'chronic/time'
+require 'chronic/time_zone'
+require 'chronic/arrow'
+
+require 'chronic/handler'
+require 'chronic/span'
+require 'chronic/token'
+require 'chronic/token_group'
+require 'chronic/tokenizer'
+
+require 'chronic/tag'
+require 'chronic/tags/day_name'
+require 'chronic/tags/day_portion'
+require 'chronic/tags/day_special'
+require 'chronic/tags/grabber'
+require 'chronic/tags/keyword'
+require 'chronic/tags/month_name'
+require 'chronic/tags/ordinal'
+require 'chronic/tags/pointer'
+require 'chronic/tags/rational'
+require 'chronic/tags/scalar'
+require 'chronic/tags/season_name'
+require 'chronic/tags/separator'
+require 'chronic/tags/sign'
+require 'chronic/tags/time_special'
+require 'chronic/tags/time_zone'
+require 'chronic/tags/unit'
+
+# 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, timezone = nil)
+    day, hour, minute, second = Time::normalize(day, hour, minute, second)
+
+    year, month, day = Date::add_day(year, month, day, 0) if day > 28
+    year, month = Date::add_month(year, month, 0) if month > 12
+
+    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
+      if timezone and timezone.respond_to?(:to_offset)
+        offset = timezone.to_offset(year, month, day, hour, minute, second)
+      else
+        offset = timezone
+      end
+      offset = TimeZone::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/arrow.rb

@@ -0,0 +1,270 @@
+module Chronic
+  class Arrow
+    BASE_UNITS = [
+      :years,
+      :months,
+      :days,
+      :hours,
+      :minutes,
+      :seconds
+    ]
+
+    UNITS = BASE_UNITS + [
+      :miliseconds,
+      :mornings,
+      :noons,
+      :afternoons,
+      :evenings,
+      :nights,
+      :midnights,
+      :weeks,
+      :weekdays,
+      :wdays,
+      :weekends,
+      :fortnights,
+      :quarters,
+      :seasons
+    ]
+
+    PRECISION = [
+      :miliseconds,
+      :seconds,
+      :minutes,
+      :noons,
+      :midnights,
+      :hours,
+      :mornings,
+      :afternoons,
+      :evenings,
+      :nights,
+      :days,
+      :weekdays,
+      :weekends,
+      :wdays,
+      :weeks,
+      :fortnights,
+      :months,
+      :quarters,
+      :seasons,
+      :years
+    ]
+
+    attr_reader :begin
+    attr_reader :end
+
+    UNITS.each { |u| attr_reader u }
+
+    attr_reader :pointer
+    attr_reader :order
+
+    def initialize(arrows, options)
+      @options = options
+      @ordered = []
+      build(arrows)
+    end
+
+    def range
+      @begin..@end
+    end
+
+    def width
+      @end - @begin
+    end
+
+    def overlap?(r2)
+      r1 = range
+      (r1.begin <= r2.end) and (r2.begin <= r1.end)
+    end
+
+    def translate_unit(unit)
+      unit.to_s + 's'
+    end
+
+    def to_span(span, timezone = nil)
+      precision = PRECISION.length - 1
+      ds = Date::split(span.begin)
+      ds += Time::split(span.begin)
+      case span.precision
+      when :year
+        precision = PRECISION.index(:years)
+        ds[3] = ds[4] = ds[5] = 0
+      when :month
+        precision = PRECISION.index(:months)
+        ds[3] = ds[4] = ds[5] = 0
+      when :day, :day_special
+        precision = PRECISION.index(:days)
+        ds[3] = ds[4] = ds[5] = 0
+      when :hour
+        precision = PRECISION.index(:hours)
+      when :minute
+        precision = PRECISION.index(:minutes)
+      when :second
+        precision = PRECISION.index(:seconds)
+      when :time_special
+        precision = 0
+      end
+
+      sign = (@pointer == :past) ? -1 : 1
+      @ordered.each do |data|
+        unit = data.first
+        count = data[1]
+        special = data.last
+        case unit
+        when *BASE_UNITS
+          ds[BASE_UNITS.index(unit)] += sign * count
+          ds[2], ds[3], ds[4], ds[5] = Time::normalize(ds[2], ds[3], ds[4], ds[5])
+          ds[0], ds[1], ds[2] = Date::normalize(ds[0], ds[1], ds[2])
+          precision = update_precision(precision, unit)
+        when :seasons
+          # TODO
+          raise "Not Implemented Arrow #{unit}"
+        when :quarters
+          ds[0], quarter = Date::add_quarter(ds[0], Date::get_quarter_index(ds[1]), sign * count)
+          ds[1] = Date::QUARTERS[quarter]
+          ds[2] = 1
+          ds[3], ds[4], ds[5] = 0, 0, 0
+          precision = PRECISION.index(unit)
+        when :fortnights
+          ds[0], ds[1], ds[2] = Date::add_day(ds[0], ds[1], ds[2], sign * count * Date::FORTNIGHT_DAYS)
+          precision = update_precision(precision, unit)
+        when :weeks
+          ds[0], ds[1], ds[2] = Date::add_day(ds[0], ds[1], ds[2], sign * count * Date::WEEK_DAYS)
+          precision = update_precision(precision, unit)
+        when :wdays
+          date = Chronic.time_class.new(ds[0], ds[1], ds[2])
+          diff = Date::wday_diff(date, special, sign)
+          ds[0], ds[1], ds[2] = Date::add_day(ds[0], ds[1], ds[2], diff + sign * (count - 1) * Date::WEEK_DAYS)
+          precision = update_precision(precision, unit)
+        when :weekends
+          date = Chronic.time_class.new(ds[0], ds[1], ds[2])
+          diff = Date::wday_diff(date, Date::DAYS[:saturday], sign)
+          ds[0], ds[1], ds[2] = Date::add_day(ds[0], ds[1], ds[2], diff + sign * (count - 1) * Date::WEEK_DAYS)
+          ds[3], ds[4], ds[5] = 0, 0, 0
+          precision = update_precision(precision, unit)
+        when :weekdays
+          # TODO
+          raise "Not Implemented Arrow #{unit}"
+        when :days
+          # TODO
+          raise "Not Implemented Arrow #{unit}"
+        when :mornings, :noons, :afternoons, :evenings, :nights, :midnights
+          name = n(unit)
+          count -= 1 if @pointer == :past and ds[3] > Time::SPECIAL[name].end
+          count += 1 if @pointer == :future and ds[3] < Time::SPECIAL[name].begin
+          ds[0], ds[1], ds[2] = Date::add_day(ds[0], ds[1], ds[2], sign * count)
+          ds[3], ds[4], ds[5] = Time::SPECIAL[name].begin, 0, 0
+          precision = PRECISION.index(unit)
+        when :miliseconds
+          # TODO
+          raise "Not Implemented Arrow #{unit}"
+        end
+      end
+
+      de = ds.dup
+      case PRECISION[precision]
+      when :miliseconds
+        de[4], de[5] = Time::add_second(ds[4], ds[5], 0.001)
+      when :seconds
+        de[4], de[5] = Time::add_second(ds[4], ds[5])
+      when :minutes
+        de[3], de[4] = Time::add_minute(ds[3], ds[4])
+        de[5] = 0
+      when :mornings, :noons, :afternoons, :evenings, :nights, :midnights
+        name = n(PRECISION[precision])
+        de[3], de[4], de[5] = Time::SPECIAL[name].end, 0, 0
+      when :hours
+        de[2], de[3] = Time::add_hour(ds[2], ds[3])
+        de[4] = de[5] = 0
+      when :days, :weekdays, :wdays
+        de[0], de[1], de[2] = Date::add_day(ds[0], ds[1], ds[2])
+        de[3] = de[4] = de[5] = 0
+      when :weekends
+        end_date = Chronic.time_class.new(ds[0], ds[1], ds[2])
+        diff = Date::wday_diff(end_date, Date::DAYS[:monday])
+        de[0], de[1], de[2] = Date::add_day(ds[0], ds[1], ds[2], diff)
+        de[3] = de[4] = de[5] = 0
+      when :weeks
+        end_date = Chronic.time_class.new(ds[0], ds[1], ds[2])
+        diff = Date::wday_diff(end_date, Date::DAYS[@options[:week_start]])
+        de[0], de[1], de[2] = Date::add_day(ds[0], ds[1], ds[2], diff)
+        de[3] = de[4] = de[5] = 0
+      when :fortnights
+        end_date = Chronic.time_class.new(ds[0], ds[1], ds[2])
+        diff = Date::wday_diff(end_date, Date::DAYS[@options[:week_start]])
+        de[0], de[1], de[2] = Date::add_day(ds[0], ds[1], ds[2], diff + Date::WEEK_DAYS)
+        de[3] = de[4] = de[5] = 0
+      when :months
+        de[0], de[1] = Date::add_month(ds[0], ds[1])
+        de[2] = 1
+        de[3] = de[4] = de[5] = 0
+      when :quarters
+        de[0], quarter = Date::add_quarter(ds[0], Date::get_quarter_index(ds[1]))
+        de[1] = Date::QUARTERS[quarter]
+        de[2] = 1
+        de[3] = de[4] = de[5] = 0
+      when :seasons
+        # TODO
+        raise "Not Implemented Arrow #{PRECISION[precision]}"
+      when :years
+        de[0] += 1
+        de[1] = de[2] = 1
+        de[3] = de[4] = de[5] = 0
+      end
+      utc_offset = nil
+      end_utc_offset = nil
+      if timezone
+        utc_offset = timezone.to_offset(ds[0], ds[1], ds[2], ds[3], ds[4], ds[5])
+        end_utc_offset = timezone.to_offset(de[0], de[1], de[2], de[3], de[4], de[5])
+      end
+      span_start = Chronic.construct(ds[0], ds[1], ds[2], ds[3], ds[4], ds[5], utc_offset)
+      span_end   = Chronic.construct(de[0], de[1], de[2], de[3], de[4], de[5], utc_offset)
+      Span.new(span_start, span_end)
+    end
+
+    def to_s
+      full = []
+      UNITS.each do |unit|
+        count = instance_variable_get('@'+unit.to_s)
+        full << [unit, count].join(' ') unless count.nil?
+      end
+      unless full.empty?
+        'Arrow => ' + @pointer.inspect + ' ' + full.join(', ')
+      else
+        'Arrow => empty'
+      end
+    end
+
+    protected
+
+    def n(unit)
+      s = unit.to_s
+      s.to_s[0, s.length - 1].to_sym
+    end
+
+    def v(v)
+      '@'+v.to_s
+    end
+
+    def update_precision(precision, unit)
+      new_precision = PRECISION.index(unit)
+      precision = new_precision if new_precision < precision
+      precision
+    end
+
+    def build(arrows)
+      arrows.each do |arrow|
+        @begin = arrow.begin if @begin.nil? or @begin > arrow.begin
+        @end = arrow.end if @end.nil? or @end < arrow.end
+        @pointer = arrow.pointer if @pointer.nil? and not arrow.pointer.nil?
+        next if arrow.unit.nil?
+        unit = translate_unit(arrow.unit)
+        raise "Uknown unit #{unit.to_sym.inspect}" unless UNITS.include?(unit.to_sym)
+        count = instance_variable_get(v(unit))
+        count ||= 0
+        @ordered << [unit.to_sym, arrow.count, arrow.special]
+        instance_variable_set(v(unit), count+arrow.count)
+      end
+    end
+
+  end
+end