Hokkaido 0.0.3 → 0.0.4

data/chronic/README.md

@@ -0,0 +1,181 @@
+Chronic
+=======
+
+## DESCRIPTION
+
+Chronic is a natural language date/time parser written in pure Ruby. See below
+for the wide variety of formats Chronic will parse.
+
+
+## INSTALLATION
+
+### RubyGems
+
+    $ [sudo] gem install chronic
+
+### GitHub
+
+    $ git clone git://github.com/mojombo/chronic.git
+    $ cd chronic && gem build chronic.gemspec
+    $ gem install chronic-<version>.gem
+
+
+## USAGE
+
+You can parse strings containing a natural language date using the
+`Chronic.parse` method.
+
+    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
+
+    Chronic.parse('this tuesday 5:00')
+      #=> Tue Aug 29 17:00:00 PDT 2006
+
+    Chronic.parse('this tuesday 5:00', :ambiguous_time_range => :none)
+      #=> Tue Aug 29 05:00:00 PDT 2006
+
+    Chronic.parse('may 27th', :now => Time.local(2000, 1, 1))
+      #=> Sat May 27 12:00:00 PDT 2000
+
+    Chronic.parse('may 27th', :guess => false)
+      #=> Sun May 27 00:00:00 PDT 2007..Mon May 28 00:00:00 PDT 2007
+      
+    Chronic.parse('6/4/2012', :endian_precedence => :little)
+      #=> Fri Apr 06 00:00:00 PDT 2012
+      
+
+See `Chronic.parse` for detailed usage instructions.
+
+
+## EXAMPLES
+
+Chronic can parse a huge variety of date and time formats. Following is a
+small sample of strings that will be properly parsed. Parsing is case
+insensitive and will handle common abbreviations and misspellings.
+
+Simple
+
+* thursday
+* november
+* summer
+* friday 13:00
+* mon 2:35
+* 4pm
+* 6 in the morning
+* friday 1pm
+* sat 7 in the evening
+* yesterday
+* today
+* tomorrow
+* this tuesday
+* next month
+* last winter
+* this morning
+* last night
+* this second
+* yesterday at 4:00
+* last friday at 20:00
+* last week tuesday
+* tomorrow at 6:45pm
+* afternoon yesterday
+* thursday last week
+
+Complex
+
+* 3 years ago
+* a year ago
+* 5 months before now
+* 7 hours ago
+* 7 days from now
+* 1 week hence
+* in 3 hours
+* 1 year ago tomorrow
+* 3 months ago saturday at 5:00 pm
+* 7 hours before tomorrow at noon
+* 3rd wednesday in november
+* 3rd month next year
+* 3rd thursday this september
+* 4th day last week
+* fourteenth of june 2010 at eleven o'clock in the evening
+* may seventh '97 at three in the morning
+
+Specific Dates
+
+* January 5
+* 22nd of june
+* 5th may 2017
+* February twenty first
+* dec 25
+* may 27th
+* October 2006
+* oct 06
+* jan 3 2010
+* february 14, 2004
+* february 14th, 2004
+* 3 jan 2000
+* 17 april 85
+* 5/27/1979
+* 27/5/1979
+* 05/06
+* 1979-05-27
+* Friday
+* 5
+* 4:00
+* 17:00
+* 0800
+
+Specific Times (many of the above with an added time)
+
+* January 5 at 7pm
+* 22nd of june at 8am
+* 1979-05-27 05:00:00
+* etc
+
+
+## TIME ZONES
+
+Chronic allows you to set which Time class to use when constructing times. By
+default, the built in Ruby time class creates times in your system's local
+time zone. You can set this to something like ActiveSupport's
+[TimeZone](http://api.rubyonrails.org/classes/ActiveSupport/TimeZone.html)
+class to get full time zone support.
+
+    >> Time.zone = "UTC"
+    >> Chronic.time_class = Time.zone
+    >> Chronic.parse("June 15 2006 at 5:45 AM")
+    => Thu, 15 Jun 2006 05:45:00 UTC +00:00
+
+
+## LIMITATIONS
+
+Chronic uses Ruby's built in Time class for all time storage and computation.
+Because of this, only times that the Time class can handle will be properly
+parsed. Parsing for times outside of this range will simply return nil.
+Support for a wider range of times is planned for a future release.
+
+
+## CONTRIBUTE
+
+If you'd like to hack on Chronic, start by forking the repo on GitHub:
+
+https://github.com/mojombo/chronic
+
+The best way to get your changes merged back into core is as follows:
+
+1. Clone down your fork
+1. Create a thoughtfully named topic branch to contain your change
+1. Hack away
+1. Add tests and make sure everything still passes by running `rake`
+1. Ensure your tests pass in multiple timezones. ie `TZ=utc rake` `TZ=BST rake`
+1. If you are adding new functionality, document it in the README
+1. Do not change the version number, we will do that on our end
+1. If necessary, rebase your commits into logical chunks, without errors
+1. Push the branch up to GitHub
+1. Send a pull request for your branch

data/chronic/Rakefile

@@ -0,0 +1,46 @@
+require 'date'
+
+def version
+  contents = File.read File.expand_path('../lib/chronic.rb', __FILE__)
+  contents[/VERSION = "([^"]+)"/, 1]
+end
+
+task :test do
+  $:.unshift './test'
+  Dir.glob('test/test_*.rb').each { |t| require File.basename(t) }
+end
+
+desc "Generate RCov test coverage and open in your browser"
+task :coverage do
+  require 'rcov'
+  sh "rm -fr coverage"
+  sh "rcov test/test_*.rb"
+  sh "open coverage/index.html"
+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
+  sh "mkdir -p pkg"
+  sh "gem build chronic.gemspec"
+  sh "mv chronic-#{version}.gem pkg"
+end
+
+task :default => :test

data/chronic/chronic.gemspec

@@ -0,0 +1,20 @@
+$:.unshift File.expand_path('../lib', __FILE__)
+require 'chronic'
+
+Gem::Specification.new do |s|
+  s.name = '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', 'lee@jarvis.co']
+  s.homepage = 'http://github.com/mojombo/chronic'
+  s.rdoc_options = ['--charset=UTF-8']
+  s.extra_rdoc_files = %w[README.md HISTORY.md LICENSE]
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- test`.split("\n")
+
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'minitest'
+end

data/chronic/lib/chronic/grabber.rb

@@ -0,0 +1,33 @@
+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|
+        if t = scan_for_all(token) then token.tag(t); next end
+      end
+    end
+
+    # token - The Token object to scan.
+    #
+    # Returns a new Grabber object.
+    def self.scan_for_all(token)
+      scan_for token, self,
+      {
+        /last/ => :last,
+        /this/ => :this,
+        /next/ => :next
+      }
+    end
+
+    def to_s
+      'grabber-' << @type.to_s
+    end
+  end
+end

data/chronic/lib/chronic/handler.rb

@@ -0,0 +1,88 @@
+module Chronic
+  class Handler
+
+    attr_reader :pattern
+
+    attr_reader :handler_method
+
+    # pattern        - An Array of patterns to match tokens against.
+    # handler_method - A Symbole representing the method to be invoked
+    #   when patterns are matched.
+    def initialize(pattern, handler_method)
+      @pattern = pattern
+      @handler_method = handler_method
+    end
+
+    # tokens - An Array of tokens to process.
+    # definitions - A Hash of definitions to check against.
+    #
+    # Returns true if a match is found.
+    def match(tokens, definitions)
+      token_index = 0
+
+      @pattern.each do |element|
+        name = element.to_s
+        optional = name[-1, 1] == '?'
+        name = name.chop if optional
+
+        case element
+        when Symbol
+          if tags_match?(name, tokens, token_index)
+            token_index += 1
+            next
+          else
+            if optional
+              next
+            else
+              return false
+            end
+          end
+        when String
+          return true if optional && token_index == tokens.size
+
+          if definitions.key?(name.to_sym)
+            sub_handlers = definitions[name.to_sym]
+          else
+            raise ChronicPain, "Invalid subset #{name} specified"
+          end
+
+          sub_handlers.each do |sub_handler|
+            return true if sub_handler.match(tokens[token_index..tokens.size], definitions)
+          end
+        else
+          raise ChronicPain, "Invalid match type: #{element.class}"
+        end
+      end
+
+      return false if token_index != tokens.size
+      return true
+    end
+
+    def invoke(type, tokens, options)
+      if Chronic.debug
+        puts "-#{type}"
+        puts "Handler: #{@handler_method}"
+      end
+
+      Handlers.send(@handler_method, tokens, options)
+    end
+
+    # other - The other Handler object to compare.
+    #
+    # Returns true if these Handlers match.
+    def ==(other)
+      @pattern == other.pattern
+    end
+
+    private
+
+    def tags_match?(name, tokens, token_index)
+      klass = Chronic.const_get(name.to_s.gsub(/(?:^|_)(.)/) { $1.upcase })
+
+      if tokens[token_index]
+        !tokens[token_index].tags.select { |o| o.kind_of?(klass) }.empty?
+      end
+    end
+
+  end
+end