dcparker-time_point 1.0.0

data/History.txt

@@ -0,0 +1,6 @@
+=== 1.0.0 / 2009-08-21
+
+* 1 major enhancement
+
+  * Initial release
+

data/Manifest.txt

@@ -0,0 +1,6 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/time_point.rb
+spec/time_point_spec.rb

data/README.txt

@@ -0,0 +1,65 @@
+= time_point
+
+* http://github.com/dcparker/time_point
+
+== DESCRIPTION:
+
+An attempt at a Ruby implementation of Martin Fowler's TimePoint pattern (http://martinfowler.com/ap2/timePoint.html). It is most certainly lacking some areas (ex. timezone support), but its algorithm for parsing the natural language for recurring time-points is quite powerful.
+
+== FEATURES/PROBLEMS:
+
+* Does not yet understand words that reference from today's date, like "Today", "Tomorrow", "Next Week".
+* Does not yet assume an end-time for a time-range when an end-time is not given. This is necessary so that '2pm Fridays' really means '2-3pm Fridays', and '2:30pm Fridays' really means '2:30-2:31pm Fridays'.
+
+== SYNOPSIS:
+
+TimePoint works to follow the true spirit of the TimePoint pattern -- the idea that every expression of time is in fact a block of time, and we mean these expressions to be to differing precisions. For example, if I say "March 5, 2000", I simply mean any time within that day -- all day. However, if I say "2:05pm March 5, 2000", I mean any second within that very specific minute. But if I say "2:00pm Fridays" I really mean every Friday, and that expression is precise to the day-of-week and to the hour and minute, but the second, week, month, or year don't matter.
+
+The main usage of TimePoint, as it currently has been built for, is TimePoint.parse and TimePoint#include?. Here are several examples:
+
+Single-point expressions:
+	t1 = TimePoint.parse('Tuesday') # All day Tuesday, every week
+	t2 = TimePoint.parse("February 24th") # Every Feb 24, all day long
+	t3 = TimePoint.parse("24 February 2001") # Feb 24 in 2001, all day long
+	t4 = TimePoint.parse("9 January 2009 and Thursday 2009") # every Thursday in 2009, and the 9th of January 2009 too
+  t5 = TimePoint.parse("1st Thursdays at 4-5pm and 1st - 4th of March at 2-3:30pm") # first thursday of every month, forever, from 4 to 5 pm; also 2 to 3:30 pm on the 1st, 2nd, 3rd, and 4th of March (every year!)
+	t6 = TimePoint.parse("2pm Fridays in January 2009 and Thursdays in 2009") # default duration of ONE of the most specific piece mentioned: 2-3pm every friday in January of '09, and also all day every thursday all year in 2009
+
+From that most complex one above, see how TimePoint#include? works:
+  t6.include?(Time.parse('2009-02-05 19:00:00')) => true
+  t6.include?(Time.parse('2009-01-09 2:31pm')) => true
+  t6.include?(Time.parse('February 5, 2010')) => false
+  t6.include?(Time.parse('January 16, 2007')) => false
+
+== REQUIREMENTS:
+
+* Just Ruby!
+
+== INSTALL:
+
+* [sudo] gem install time_point
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 BehindLogic <gems@behindlogic.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,36 @@
+require 'rubygems'
+require 'hoe'
+require './lib/time_point'
+
+Dir['tasks/**/*.rake'].each { |rake| load rake }
+
+Hoe.new('time_point', TimePoint::VERSION) do |p|
+  p.author      = 'Daniel Parker'
+  p.email       = 'gems@behindlogic.com'
+  p.summary     = "A parser for definitions of recurring events in natural English."
+  p.description = "A parser for definitions of recurring events in natural English."
+  p.url         = 'http://github.com/dcparker/time_point'
+  p.changes     = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+end
+
+desc "Generate gemspec"
+task :gemspec do |x|
+  # Check the manifest before generating the gemspec
+  manifest = %x[rake check_manifest]
+  manifest.gsub!(/\(in [^\)]+\)\n/, "")
+
+  unless manifest.empty?
+    print "\n", "#"*68, "\n"
+    print <<-EOS
+  Manifest.txt is not up-to-date. Please review the changes below.
+  If the changes are correct, run 'rake check_manifest | patch'
+  and then run this command again.
+EOS
+    print "#"*68, "\n\n"
+    puts manifest
+  else
+    gemspec = `rake debug_gem`
+    gemspec.gsub!(/\(in [^\)]+\)\n/, "")
+    File.open("time_point.gemspec", 'w') {|f| f.write(gemspec) }
+  end
+end

data/lib/time_point.rb

@@ -0,0 +1,415 @@
+require 'date'
+require 'time'
+
+class Array
+  def includes_sequence?(sequence)
+    first_exists = []
+    each_index do |i|
+      first_exists << i if self[i] == sequence[0]
+    end
+    first_exists.any? do |i|
+      return i if self[i...(i+sequence.length)] == sequence
+    end
+  end
+
+  def include_value?(v)
+    any? do |iv|
+      case iv
+      when Range || Array
+        v.to_i.in?(iv)
+      else
+        if iv.to_s =~ /^\d+$/ && v.to_s =~ /^\d+$/
+          iv.to_i == v.to_i
+        else
+          iv.to_s == v.to_s
+        end
+      end
+    end
+  end
+end
+
+class Range
+  alias :include_value? :include?
+end
+
+class Object
+  def value_in?(*arg)
+    arg = arg[0] if arg.length == 1 && arg[0].respond_to?(:include_value?)
+    arg.include_value?(self)
+  end
+  def in?(*arg)
+    arg = arg[0] if arg.length == 1 && arg[0].respond_to?(:include?)
+    arg.include?(self)
+  end
+  def my_methods
+    methods.sort - Object.methods
+  end
+end
+
+module WdayOrd
+  def wday_ord
+    (day.to_f / 7).ceil
+  end
+end
+class DateTime
+  include WdayOrd
+end
+class Time
+  include WdayOrd
+end
+
+class TimePoint
+  VERSION = '1.0.0'
+  class ArrayOfRanges < Array
+    def self.new(*values)
+      n = allocate
+      n.push(*values)
+      n
+    end
+  end
+
+  class Classification
+    class << self
+      attr_reader :order, :translations
+
+      def abbreviations
+        @abbreviations ||= translations.inject({}) do |h,(k,v)|
+          h[v] = k unless h.has_key?(v) && h[v].length < k.length
+          h
+        end
+      end
+    end
+  end
+  
+  class WDay < Classification
+    @order = %w(Sunday Monday Tuesday Wednesday Thursday Friday)
+    @translations = {
+      'S' => 'Sunday',
+      'M' => 'Monday',
+      'T' => 'Tuesday',
+      'W' => 'Wednesday',
+      'Th' => 'Thursday',
+      'F' => 'Friday',
+      'Sa' => 'Saturday',
+      'Sundays' => 'Sunday',
+      'Mondays' => 'Monday',
+      'Tuesdays' => 'Tuesday',
+      'Wednesdays' => 'Wednesday',
+      'Thursdays' => 'Thursday',
+      'Fridays' => 'Friday',
+      'Saturdays' => 'Saturday'
+    }
+  end
+  class Month < Classification
+    @order = %w(January February March April May June July August September October November December)
+    @translations = {
+      'Jan' => 'January',
+      'Feb' => 'February',
+      'Mar' => 'March',
+      'Apr' => 'April',
+      'Jun' => 'June',
+      'Jul' => 'July',
+      'Aug' => 'August',
+      'Sep' => 'September',
+      'Oct' => 'October',
+      'Nov' => 'November',
+      'Dec' => 'December'
+    }
+  end
+
+  # These are in a specific order
+  CommonPatterns = [
+    'ord range ord',
+    'ord union ord',
+    'wday range wday',
+    'wday union wday',
+    'month ord',
+    'ord wday',
+    'ord month timerange',
+    'month_ord timerange',
+    'month union month',
+    'month range month',
+    'ord_wday month',
+    'ord_wday timerange',
+    'ord_wday_month timerange'
+  ]
+  CommonPatternActions = {
+    'ord range ord' => lambda {|words,i|
+      words[i][:ord] = (words[i][:ord].to_i..words[i+2][:ord].to_i)
+      words.slice!(i+1,2)
+    },
+    'ord union ord' => lambda {|words,i|
+      words[i][:ord] = ArrayOfRanges.new(words[i][:ord], words[i+2][:ord])
+      words.slice!(i+1,2)
+    },
+    'wday range wday' => lambda {|words,i|
+      words[i][:wday] = (words[i][:wday].to_i..words[i+2][:wday].to_i)
+      words.slice!(i+1,2)
+    },
+    'wday union wday' => lambda {|words,i|
+      words[i][:wday] = ArrayOfRanges.new(words[i][:wday], words[i+2][:wday])
+      words.slice!(i+1,2)
+    },
+    'month ord' => lambda {|words,i|
+      words[i][:type] = 'month_ord'
+      words[i][:ord] = words[i+1][:ord]
+      words.slice!(i+1,1)
+    },
+    'ord wday' => lambda {|words,i|
+      words[i][:type] = 'ord_wday'
+      words[i][:wday] = words[i+1][:wday]
+      words.slice!(i+1,1)
+    },
+    'ord month timerange' => lambda {|words,i|
+      words[i][:type] = 'month_ord_timerange'
+      words[i][:month] = words[i+1][:month]
+      words[i][:start_time] = words[i+2][:start_time]
+      words[i][:end_time] = words[i+2][:end_time]
+      words.slice!(i+1,2)
+    },
+    'month_ord timerange' => lambda {|words,i|
+      words[i][:type] = 'month_ord_timerange'
+      words[i][:start_time] = words[i+1][:start_time]
+      words[i][:end_time] = words[i+1][:end_time]
+      words.slice!(i+1,1)
+    },
+    'month union month' => lambda {|words,i|
+      words[i][:month] = ArrayOfRanges.new(words[i][:month], words[i+2][:month])
+      words.slice!(i+1,2)
+    },
+    'month range month' => lambda {|words,i|
+      raise "Not Implemented Yet!"
+    },
+    'ord_wday month' => lambda {|words,i|
+      words[i][:type] = 'ord_wday_month'
+      words[i][:month] = words[i+1][:month]
+      words.slice!(i+1,1)
+    },
+    'ord_wday timerange' => lambda {|words,i|
+      words[i][:type] = 'ord_wday_timerange'
+      words[i][:start_time] = words[i+1][:start_time]
+      words[i][:end_time] = words[i+1][:end_time]
+      words.slice!(i+1,1)
+    },
+    'ord_wday_month timerange' => lambda {|words,i|
+      words[i][:type] = 'ord_wday_month_timerange'
+      words[i][:start_time] = words[i+1][:start_time]
+      words[i][:end_time] = words[i+1][:end_time]
+      words.slice!(i+1,1)
+    }
+  }
+
+  BooleanPatterns = [
+    'union'
+  ]
+
+  BooleanPatternActions = {
+    'union' => lambda {|words,i|
+      words[i-1] = TimePoint::Union.new(words[i-1], words[i+1])
+      words.slice!(i,2)
+      puts words.inspect if $DEBUG
+    }
+  }
+
+  TimeRegexp = '\d{1,2}(?::\d{1,2})?(?:am|pm)'
+  WordTypes = {
+    :ord => /^(\d+)(?:st|nd|rd|th)?$/i,
+    :wday => /^(#{WDay.order.join('|')})s$/i,
+    :month => /^#{Month.order.join('|')}$/i,
+    :union => /^(?:and)$/i,
+    :range => /^(?:-|to|through)$/,
+    :timerange => /^(#{TimeRegexp}?)-(#{TimeRegexp})$/i,
+    :time => /^#{TimeRegexp}$/i
+  }
+  
+  class << self
+    def parse(expression)
+      # 1. Normalize the expression
+      # TODO: re-create normalize: ' -&| ', 'time-time'
+      expression.gsub!(/([\-\&\|])/,' \1 ')
+      expression.gsub!(/(#{TimeRegexp}?)\s+-\s+(#{TimeRegexp})/,'\1-\2')
+
+      # 2. Analyze the expression
+      words = expression.split(/\s+/)
+      puts words.inspect if $DEBUG
+      analyzed_expression = words.inject([]) do |a,word|
+        a << case word
+        when WordTypes[:ord]
+          {:type => 'ord', :ord => $1}
+        when WordTypes[:wday]
+          {:type => 'wday', :wday => $1}
+        when WordTypes[:month]
+          {:type => 'month', :month => word}
+        when WordTypes[:union]
+          {:type => 'union'}
+        when WordTypes[:range]
+          {:type => 'range'}
+        when WordTypes[:timerange]
+          {:type => 'timerange', :start_time => $1, :end_time => $2}
+        when WordTypes[:time]
+          {:type => 'time', :time => word}
+        end
+      end.compact
+      def analyzed_expression.collect_types
+        collect {|e| e[:type]}
+      end
+
+      # 3. Combine common patterns
+      puts analyzed_expression.inspect if $DEBUG
+      puts analyzed_expression.collect_types.inspect if $DEBUG
+
+      something_was_modified = true
+      while something_was_modified
+        something_was_modified = false
+        before_length = analyzed_expression.length
+        CommonPatterns.each do |pattern|
+          while i = analyzed_expression.collect_types.includes_sequence?(pattern.split(/ /))
+            CommonPatternActions[pattern].call(analyzed_expression,i)
+          end
+        end
+        after_length = analyzed_expression.length
+        something_was_modified = true if before_length != after_length
+      end
+      
+      puts analyzed_expression.inspect if $DEBUG
+      puts analyzed_expression.collect_types.inspect if $DEBUG
+
+      # What remains should be simply sections of boolean logic
+      # 4. Parse boolean logic
+      analyzed_expression.each_index do |i|
+        analyzed_expression[i] = TimePoint.new(analyzed_expression[i]) unless ['union', 'range'].include? analyzed_expression[i][:type]
+      end
+
+      BooleanPatterns.each do |pattern|
+        while i = analyzed_expression.collect_types.includes_sequence?(pattern.split(/ /))
+          BooleanPatternActions[pattern].call(analyzed_expression,i)
+          break if analyzed_expression.length == 1
+        end
+      end
+
+      return analyzed_expression[0]
+    end
+  end
+
+  def initialize(options)
+    options.each do |key,value|
+      instance_variable_set(:"@#{key}", value)
+    end
+  end
+
+  def [](key)
+    instance_variable_get(:"@#{key}")
+  end
+
+  def start_pm?
+    if @start_time =~ /(am|pm)$/ || @end_time =~ /(am|pm)$/
+      $1 == 'pm'
+    else
+      nil
+    end
+  end
+
+  def include?(datetime)
+    return false unless occurs_on_day?(datetime)
+    if @type =~ /timerange/
+      test_date = datetime.strftime("%Y-%m-%d")
+      test_start_time = Time.parse("#{test_date} #{@start_time}#{start_pm? ? 'pm' : 'am'}")
+      test_end_time = Time.parse("#{test_date} #{@end_time}")
+      puts "TimeRange: date:#{test_date} test_start:#{test_start_time} test_end:#{test_end_time} <=> #{datetime}" if $DEBUG
+      return false unless datetime.between?(test_start_time, test_end_time)
+    end
+    return true
+    puts "#{datetime} Included!" if $DEBUG
+  end
+
+  def occurs_on_day?(datetime)
+    puts "#{datetime} IN? #{inspect}" if $DEBUG
+    puts "Correct month? #{Month.order[datetime.month-1].inspect}==#{@month.inspect} : #{Month.order[datetime.month-1].value_in?(@month)}" if @type =~ /month/ if $DEBUG
+    return false if @type =~ /month/ && !Month.order[datetime.month-1].value_in?(@month)
+    if @type =~ /ord_wday/
+      puts "Weekday: #{WDay.order[datetime.wday].inspect} in? #{@wday.inspect} == #{WDay.order[datetime.wday].value_in?(@wday)}" if $DEBUG
+      return false unless WDay.order[datetime.wday].value_in?(@wday)
+      puts "WeekdayOrd: #{datetime.wday_ord} in? #{@ord.inspect} == #{datetime.wday_ord.value_in?(@ord)}" if $DEBUG
+      return false unless datetime.wday_ord.value_in?(@ord)
+    end
+    if @type =~ /month_ord/
+      puts "Day #{datetime.day} == #{@ord.inspect} >> #{datetime.day.value_in?(@ord)}" if $DEBUG
+      return false unless datetime.day.value_in?(@ord)
+    end
+    # puts "Type: #{@type}" if $DEBUG
+    # case
+    # when @type == 'ord_wday_month'
+    #   return true
+    # when @type == 'ord_wday_month_timerange'
+    #   return true
+    # when @type == 'ord_wday_timerange'
+    #   return true
+    # when @type == 'month_ord_timerange'
+    # end
+    puts "Occurs on #{datetime}!" if $DEBUG
+    return true
+  end
+
+  def occurrances_on_day(date)
+    occurs_on_day?(date) ? [{:start_time => start_time(date), :end_time => end_time(date)}] : []
+  end
+
+  def start_time(date=nil)
+    if date
+      Time.parse("#{date.strftime("%Y-%m-%d")} #{@start_time}#{start_pm? ? 'pm' : 'am'}")
+    else
+      @start_time
+    end
+  end
+  def end_time(date=nil)
+    if date
+      Time.parse("#{date.strftime("%Y-%m-%d")} #{@end_time}")
+    else
+      @end_time
+    end
+  end
+
+  class Union
+    def set
+      @set ||= []
+    end
+
+    def initialize(*args)
+      # @set = args.select {|e| e.is_a?(TimePoint) || e.is_a?(Range)}
+      @set = args.select {|e| e.is_a?(TimePoint)}
+      # @set = args
+    end
+
+    def include?(other)
+      set.any? {|tp| tp.include?(other)}
+    end
+
+    def occurs_on_day?(other)
+      set.any? {|tp| tp.occurs_on_day?(other)}
+    end
+
+    def occurrances_on_day(other)
+      set.inject([]) {|a,tp| a.concat(tp.occurrances_on_day(other)); a}
+    end
+
+    def eql?(other)
+      if other.is_a?(TimePoint::Union)
+        set.length == other.length && set.length.times { |i| return false unless set[i].eql? other[i] }
+      else
+        # what else can we compare to?
+        raise "Comparison of TimePointSet with something different (#{other.class.name})."
+      end
+    end
+
+    private
+    # Sends all other methods to the set array.
+    def method_missing(name, *args, &block)
+      if set.respond_to?(name)
+        args << block if block_given?
+        set.send(name, *args)
+      else
+        super
+      end
+    end
+  end
+end

data/spec/time_point_spec.rb

@@ -0,0 +1,43 @@
+require 'rubygems'
+require 'spec'
+require File.dirname(__FILE__) + '../lib/time_point'
+
+describe TimePoint do
+  it "1st-2nd And 4th Thursdays Of March And April 5-6:30pm And March 16th - 24th At 2-2:30pm" do
+    t = TimePoint.parse("1st-2nd And 4th Thursdays Of March And April 5-6:30pm And March 16th - 24th At 2-2:30pm")
+    # march 5, 12, 26, april 2, 9, 23
+    t.include?(Time.parse('2009-03-05 5:54pm')).should eql(true)
+    t.include?(Time.parse('2009-03-05 18:24')).should eql(true)
+    t.include?(Time.parse('2009-03-05 18:30')).should eql(true)
+    t.include?(Time.parse('2009-03-05 18:31')).should eql(false)
+    # t.include?(Time.parse('2009-04-26 18:31')).should eql(false)
+    t.occurs_on_day?(Time.parse('2009-03-04')).should_not eql(true)
+    t.occurs_on_day?(Time.parse('2009-03-11')).should_not eql(true)
+    t.occurs_on_day?(Time.parse('2009-03-25')).should_not eql(true)
+    t.occurs_on_day?(Time.parse('2009-04-01')).should_not eql(true)
+    t.occurs_on_day?(Time.parse('2009-04-08')).should_not eql(true)
+    t.occurs_on_day?(Time.parse('2009-04-22')).should_not eql(true)
+    t.occurs_on_day?(Time.parse('2009-03-05')).should eql(true)
+    t.occurs_on_day?(Time.parse('2009-03-12')).should eql(true)
+    t.occurs_on_day?(Time.parse('2009-03-26')).should eql(true)
+    t.occurs_on_day?(Time.parse('2009-04-02')).should eql(true)
+    t.occurs_on_day?(Time.parse('2009-04-09')).should eql(true)
+    t.occurs_on_day?(Time.parse('2009-04-23')).should eql(true)
+    t.occurs_on_day?(Time.parse('2009-03-06')).should_not eql(true)
+    t.occurs_on_day?(Time.parse('2009-03-13')).should_not eql(true)
+    t.occurs_on_day?(Time.parse('2009-03-27')).should_not eql(true)
+    t.occurs_on_day?(Time.parse('2009-04-03')).should_not eql(true)
+    t.occurs_on_day?(Time.parse('2009-04-10')).should_not eql(true)
+    t.occurs_on_day?(Time.parse('2009-04-24')).should_not eql(true)
+    t.occurrances_on_day(Time.parse('2009-04-26')).length.should eql(0)
+    t.occurrances_on_day(Time.parse('2009-04-23')).length.should eql(1)
+  end
+
+  it "1st Thursdays at 4-5pm and 1st - 4th of March at 2-3:30pm" do
+    t = TimePoint.parse("1st Thursdays at 4-5pm and 1st - 4th of March and April at 2-3:30pm")
+    t.occurs_on_day?(Time.parse('2009-04-02')).should eql(true)
+    t.occurrances_on_day(Time.parse('2009-04-01')).length.should eql(1)
+    t.occurrances_on_day(Time.parse('2009-04-02')).length.should eql(2)
+    t.occurrances_on_day(Time.parse('2009-05-07')).length.should eql(1)
+  end
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification 
+name: dcparker-time_point
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Daniel Parker
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-08-21 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.8.3
+    version: 
+description: A parser for definitions of recurring events in natural English.
+email: gems@behindlogic.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- lib/time_point.rb
+- spec/time_point_spec.rb
+has_rdoc: false
+homepage: http://github.com/dcparker/time_point
+licenses: 
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: time_point
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A parser for definitions of recurring events in natural English.
+test_files: []
+