ice_cube_english 0.1

data/README.rdoc

@@ -0,0 +1,51 @@
+== ice_cube_english - easy date expansion in English
+
+    gem install ice_cube_english
+
+ice_cube_english provides english-language date and time parsing for ice_cube.
+
+Imagine you want:
+
+    Every friday the 13th that falls in October
+
+You would write:
+
+    schedule.add_recurrence_rule "Every friday the 13th that falls in October"
+
+---
+
+===Contributors
+
+* Dwayne Litzenberger - dlitz@patientway.com
+
+---
+
+===Issues?
+
+Lighthouse: https://github.com/dlitz/ice_cube_english/issues
+
+---
+
+===License
+
+(The MIT License)
+
+Copyright © 2011 Infonium Inc.
+
+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/lib/ice_cube/english.rb

@@ -0,0 +1,2 @@
+require 'ice_cube/english/rule_extension'
+require 'ice_cube/english/schedule_extension'

data/lib/ice_cube/english/grammar_helper.rb

@@ -0,0 +1,107 @@
+module IceCube
+  module English
+    module GrammarHelper
+      class <<self
+        def deep_merge!(result, hash)
+          hash.each_pair do |k,v|
+            case v
+            when Hash
+              if result.include?(k)
+                raise ArgumentError("type mismatch: #{k.inspect}: #{v.class.name} -> #{result[k].class.name}") unless result[k].is_a?(Hash)
+                deep_merge!(result[k], v)
+              else
+                result[k] = {}
+                deep_merge!(result[k], v)
+              end
+            when Array
+              if result.include?(k)
+                raise ArgumentError("type mismatch: #{k.inspect}: #{v.class.name} -> #{result[k].class.name}") unless result[k].is_a?(Array)
+                result[k] += v
+              else
+                result[k] = []
+                result[k] += v
+              end
+            else
+              result[k] = v
+            end
+          end
+          result
+        end
+      end
+
+      RULE_TYPES = {
+        "secondly" => "IceCube::SecondlyRule",
+        "seconds" => "IceCube::SecondlyRule",
+        "second" => "IceCube::SecondlyRule",
+        "minutely" => "IceCube::MinutelyRule",
+        "minutes" => "IceCube::MinutelyRule",
+        "minute" => "IceCube::MinutelyRule",
+        "hourly" => "IceCube::HourlyRule",
+        "hours" => "IceCube::HourlyRule",
+        "hour" => "IceCube::HourlyRule",
+        "daily" => "IceCube::DailyRule",
+        "days" => "IceCube::DailyRule",
+        "day" => "IceCube::DailyRule",
+        "weekly" => "IceCube::WeeklyRule",
+        "weeks" => "IceCube::WeeklyRule",
+        "week" => "IceCube::WeeklyRule",
+        "monthly" => "IceCube::MonthlyRule",
+        "months" => "IceCube::MonthlyRule",
+        "month" => "IceCube::MonthlyRule",
+        "annually" => "IceCube::YearlyRule",
+        "yearly" => "IceCube::YearlyRule",
+        "years" => "IceCube::YearlyRule",
+        "year" => "IceCube::YearlyRule",
+      }
+
+      DAYS = {
+        "sundays" => 0,
+        "sunday" => 0,
+        "mondays" => 1,
+        "monday" => 1,
+        "tuesdays" => 2,
+        "tuesday" => 2,
+        "wednesdays" => 3,
+        "wednesday" => 3,
+        "thursdays" => 4,
+        "thursday" => 4,
+        "fridays" => 5,
+        "friday" => 5,
+        "saturdays" => 6,
+        "saturday" => 6,
+      }
+
+      DAYS_OF_WEEK = {
+        "sundays" => :sunday,
+        "sunday"  => :sunday,
+        "mondays" => :monday,
+        "monday"  => :monday,
+        "tuesdays" => :tuesday,
+        "tuesday"  => :tuesday,
+        "wednesdays" => :wednesday,
+        "wednesday"  => :wednesday,
+        "thursdays" => :thursday,
+        "thursday"  => :thursday,
+        "fridays" => :friday,
+        "friday"  => :friday,
+        "saturdays" => :saturday,
+        "saturday"  => :saturday,
+      }
+
+      MONTHS_OF_YEAR = {
+        "january" => :january,
+        "february"  => :february,
+        "march" => :march,
+        "april"  => :april,
+        "may" => :may,
+        "june"  => :june,
+        "july" => :july,
+        "august"  => :august,
+        "september" => :september,
+        "october"  => :october,
+        "november" => :november,
+        "december"  => :december,
+      }
+    end
+  end
+end

data/lib/ice_cube/english/rule_extension.rb

@@ -0,0 +1,36 @@
+require 'treetop'
+require 'ice_cube'
+require 'ice_cube/english/schedule_grammar'
+require 'ice_cube/english/rule_grammar'
+
+module IceCube
+  module English
+    module RuleExtension
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+      module ClassMethods
+        # Return a new IceCube rule corresponding to the specified english string.
+        #
+        # If the :multiple option is set, return an Array of rules.
+        def from_english(string, options={})
+          if options[:multiple]
+            grammar = ::IceCube::English::ScheduleGrammarParser.new
+            parse_tree = grammar.parse(string.downcase)
+            raise ArgumentError.new(grammar.failure_reason) unless parse_tree
+            parse_tree.attribute_hashes.map{ |h| from_hash(h) }
+          else
+            grammar = ::IceCube::English::RuleGrammarParser.new
+            parse_tree = grammar.parse(string.downcase)
+            raise ArgumentError.new(grammar.failure_reason) unless parse_tree
+            from_hash(parse_tree.attributes)
+          end
+        end
+      end
+    end
+  end
+end
+
+class ::IceCube::Rule # reopen
+  include ::IceCube::English::RuleExtension
+end

data/lib/ice_cube/english/rule_grammar.treetop

@@ -0,0 +1,454 @@
+require 'ice_cube/english/grammar_helper'
+
+module IceCube
+  module English
+    grammar RuleGrammar
+      rule recurrence_rule
+        first_clause:recurrence_clause rest_clauses:( WS+ recurrence_clause )* {
+          def clauses
+            [first_clause] + rest_clauses
+          end
+
+          def rest_clauses
+            super.elements.map{|c| c.recurrence_clause}
+          end
+
+          def attributes
+            clause_attributes = []
+            clauses.each do |c|
+              clause_attributes << c.attributes
+            end
+
+            result = {:until => nil, :count => nil, :interval => 1, :validations => {}}
+            clause_attributes.each do |attributes|
+              GrammarHelper.deep_merge!(result, attributes)
+            end
+
+            # If :minute_of_hour is specified, make sure :second_of_minute is also specified.
+            if result[:validations][:minute_of_hour] and !result[:validations][:second_of_minute]
+              result[:validations][:second_of_minute] = [0]
+            end
+
+            # Make sure :rule_type is specified
+            unless result[:rule_type]
+              # XXX - Is this correct?  Is it necessary to differentiate between these cases?
+              v = result[:validations]
+              result[:rule_type] = "IceCube::SecondlyRule"
+              result[:rule_type] = "IceCube::MinutelyRule" if (v[:second_of_minute] && v[:second_of_minute].length == 1) || v[:minute_of_hour]
+              result[:rule_type] = "IceCube::HourlyRule" if (v[:minute_of_hour] && v[:minute_of_hour].length == 1) || v[:hour_of_day]
+              result[:rule_type] = "IceCube::DailyRule" if v[:hour_of_day] && v[:hour_of_day].length == 1 || v[:day] || v[:day_of_week]
+              result[:rule_type] = "IceCube::WeeklyRule" if (v[:day] ? v[:day].length : 0) + (v[:day_of_week] ? v[:day_of_week].length : 0) == 1 || v[:day_of_month]
+              result[:rule_type] = "IceCube::MonthlyRule" if (v[:day_of_week] && v[:day_of_week].values.map{|vv| vv.length}.inject{|a,b| a+b} == 1) || (v[:day_of_month] && v[:day_of_month].length == 1)
+            end
+            result
+          end
+        }
+      end
+
+      rule recurrence_clause
+        frequency / for_n_occurrences / on_the_nth_x_of_the_y / the_nth / at_minutes_past_the_hour / at_time_of_day / of_month
+      end
+
+      # e.g. "daily", "every 2 days", "every 2nd day", "every monday", "every 2 mondays"
+      rule frequency
+        direct_frequency / every_frequency
+      end
+
+      rule direct_frequency
+        ( "secondly" / "minutely" / "hourly" / "daily" / "weekly" / "monthly" / "yearly" / "annually" ) {
+          def attributes
+            { :rule_type => GrammarHelper::RULE_TYPES[text_value] }
+          end
+        }
+      end
+
+      # e.g. "every day", "every 2nd day", "every 2nd monday", "every monday", "every 2 mondays"
+      rule every_frequency
+        "every" WS+
+        n:( m:positive_integer_or_ordinal WS+ )?
+        unit:( "seconds" / "minutes" / "hours" / "days" / "weeks" / "months" / "years" /
+               "second" / "minute" / "hour" / "day" / "week" / "month" / "year" /
+               days_of_week )
+        {
+          def attributes
+            result = {}
+            result[:interval] = n.m.number unless n.empty?
+            if unit.respond_to?(:day_validations)   # days_of_week
+              result[:validations] = { :day => unit.day_validations }
+            else
+              result[:rule_type] = GrammarHelper::RULE_TYPES[unit.text_value]
+            end
+            result
+          end
+        }
+      end
+
+      rule days_of_week
+        first_day:day_of_week rest_days:( comma_joiner day_of_week )*
+        {
+          def days
+            [first_day] + rest_days
+          end
+
+          def rest_days
+            super.elements.map{|d| d.day_of_week}
+          end
+
+          def day_validations
+            days.map{|day_of_week| day_of_week.day_validation}
+          end
+        }
+      end
+
+      rule day_of_week
+        ( "sundays" / "mondays" / "tuesdays" / "wednesdays" / "thursdays" / "fridays" / "saturdays" /
+          "sunday" / "monday" / "tuesday" / "wednesday" / "thursday" / "friday" / "saturday" )
+        {
+          def day_validation
+            GrammarHelper::DAYS[text_value]
+          end
+        }
+      end
+
+      # e.g. "every second", "every 1 second", "every 2 seconds"
+      rule number_frequency
+        n:( positive_integer WS+ )? time_unit {
+          def attributes
+            { :rule_type => GrammarHelper::RULE_TYPES[time_unit.text_value], :interval => n.text_value.to_i }
+          end
+        }
+      end
+
+      rule for_n_occurrences
+        "for" WS+ positive_integer WS+ ( "occurrences" / "occurrence" ) {
+          def count
+            positive_integer.number
+          end
+
+          def attributes
+            { :count => count }
+          end
+        }
+      end
+
+      rule on_the_nth_x_of_the_y
+        "on" WS+ "the" WS+ ordinals WS+ ("seconds" / "second") WS+ "of" WS+ "the" WS+ "minute" {
+          def attributes
+            { :validations => {:second_of_minute => ordinals.numbers} }
+          end
+        }
+        /
+        "on" WS+ "the" WS+ ordinals WS+ ("minutes" / "minute") WS+ "of" WS+ "the" WS+ "hour" {
+          def attributes
+            { :validations => {:minute_of_hour => ordinals.numbers} }
+          end
+        }
+        /
+        "on" WS+ "the" WS+ lordinals WS+ ("days" / "day") WS+ "of" WS+ "the" WS+ "month" {
+          def attributes
+            { :validations => {:day_of_month => lordinals.numbers} }
+          end
+        }
+        /
+        "on" WS+ "the" WS+ lordinals WS+ days_of_week ( WS+ "of" WS+ "the" WS+ "month" )? {
+          def attributes
+            result = {}
+            days_of_week.days.each do |day_of_week|
+              GrammarHelper.deep_merge! result, { :validations => { :day_of_week => { GrammarHelper::DAYS_OF_WEEK[day_of_week.text_value] => lordinals.numbers } } }
+            end
+            result
+          end
+        }
+      end
+
+      # e.g. "the 13th"
+      rule the_nth
+        "the" WS+ ordinal {
+          def attributes
+            { :validations => {:day_of_month => [ordinal.number]} }
+          end
+        }
+      end
+
+      # e.g. "that falls in october", "of october", "in October"
+      rule of_month
+        ( "of" / "in" / "that" WS+ "falls" WS+ "in" ) WS+ month_names {
+          def attributes
+            { :validations => {:month_of_year => month_names.months_of_year} }
+          end
+        }
+      end
+
+      rule month_names
+        first_month_name:month_name rest_month_names:(comma_joiner month_name)* {
+          def month_names
+            [first_month_name] + rest_month_names
+          end
+
+          def rest_month_names
+            super.elements.map{|e| e.month_name}
+          end
+
+          def months_of_year
+            month_names.map{|m| GrammarHelper::MONTHS_OF_YEAR[m.text_value]}
+          end
+        }
+      end
+
+      rule month_name
+        ( "january" / "february" / "march" / "april" / "may" / "june" /
+          "july" / "august" / "september" / "october" / "november" / "december" )
+      end
+
+      # e.g. "at 15 minutes past the hour"
+      rule at_minutes_past_the_hour
+        "at" WS+ int60s WS+ "minutes" WS+ "past" WS+ "the" WS+ "hour" {
+          def attributes
+            { :validations => {:minute_of_hour => int60s.numbers} }
+          end
+        }
+      end
+
+      rule time_unit
+        "seconds" / "minutes" / "hours" / "days" / "weeks" / "months" / "years" /
+        "second" / "minute" / "hour" / "day" / "week" / "month" / "year"
+      end
+
+      rule ordinal
+        ( "first" / positive_integer ( "st" / "nd" / "rd" / "th" ) ) {
+          def number
+            if text_value == "first"
+              1
+            else
+              positive_integer.text_value.to_i
+            end
+          end
+        }
+      end
+
+      rule ordinals
+        first_ordinal:ordinal rest_ordinals:(comma_joiner ordinal)* {
+          def ordinals
+            [first_ordinal] + rest_ordinals
+          end
+
+          def rest_ordinals
+            super.elements.map{|e| e.ordinal}
+          end
+
+          def numbers
+            ordinals.map{|o| o.number}
+          end
+        }
+      end
+
+      # ordinal, including "last", "2nd last", etc.
+      rule lordinal
+        ( "first" / "last" / positive_integer ( "st" / "nd" / "rd" / "th" ) l:(WS+ "last")? ) {
+          def number
+            if text_value == "first"
+              1
+            elsif text_value == "last"
+              -1
+            elsif l.empty?
+              positive_integer.text_value.to_i
+            else
+              -(positive_integer.text_value.to_i)
+            end
+          end
+        }
+      end
+
+      rule lordinals
+        first_lordinal:lordinal rest_lordinals:(comma_joiner lordinal)* {
+          def lordinals
+            [first_lordinal] + rest_lordinals
+          end
+
+          def rest_lordinals
+            super.elements.map{|e| e.lordinal}
+          end
+
+          def numbers
+            lordinals.map{|o| o.number}
+          end
+        }
+      end
+
+      rule positive_integer_or_ordinal
+        ( "first" / positive_integer ( "st" / "nd" / "rd" / "th" )? ) {
+          def number
+            if text_value == "first"
+              1
+            else
+              positive_integer.text_value.to_i
+            end
+          end
+        }
+      end
+
+      rule nonnegative_integers
+        first_nonnegative_integer:nonnegative_integer rest_nonnegative_integers:(comma_joiner nonnegative_integer)* {
+          def nonnegative_integers
+            [first_nonnegative_integer] + rest_nonnegative_integers
+          end
+
+          def rest_nonnegative_integers
+            super.elements.map{|e| e.nonnegative_integer}
+          end
+
+          def numbers
+            nonnegative_integers.map{|n| n.number}
+          end
+        }
+      end
+
+      rule nonnegative_integer
+        "0" / positive_integer
+      end
+
+      rule positive_integer
+        [1-9] [0-9]* {
+          def number
+            text_value.to_i
+          end
+        }
+      end
+
+      rule at_time_of_day
+        "at" WS+ t:( twelve_noon_or_midnight / time12 / time24 ) {
+          def attributes
+            { :validations => { :hour_of_day => [t.hour], :minute_of_hour => [t.minute], :second_of_minute => [t.second] } }
+          end
+        }
+      end
+
+      # Time of day (24-hour clock)
+      rule time24
+        h:hour24 a:( ":" m:int60 b:( ":" s:int60 )? )?
+        {
+          def hour
+            h.text_value.to_i
+          end
+
+          def minute
+            return 0 if a.empty?
+            a.m.number
+          end
+
+          def second
+            return 0 if a.empty? or a.b.empty?
+            a.b.s.number
+          end
+        }
+      end
+
+      # Time of day (12-hour clock)
+      rule time12
+        h:hour12 a:( ":" m:int60 b:( ":" s:int60 )? )? WS* c:( "am" / "a.m." / "pm" / "p.m." ) {
+          def hour
+            hr = h.text_value.to_i
+            if c.text_value =~ /\Ap/
+              # PM
+              if hr == 12
+                12
+              else
+                hr + 12
+              end
+            else
+              # AM
+              if hr == 12
+                0
+              else
+                hr
+              end
+            end
+          end
+
+          def minute
+            return 0 if a.empty?
+            a.m.text_value.to_i
+          end
+
+          def second
+            return 0 if a.empty? or a.b.empty?
+            a.b.s.text_value.to_i
+          end
+        }
+      end
+
+      # Noon or midnight
+      rule twelve_noon_or_midnight
+        ( "12" ( ":" "00" ( ":" "00" )? )? WS+ )? a:( "noon" / "midnight") {
+          def hour
+            if a.text_value == "noon"
+              12
+            else
+              0
+            end
+          end
+
+          def minute
+            0
+          end
+
+          def second
+            0
+          end
+        }
+      end
+
+      # The numbers 1 though 12 (possibly padded to 2 digits)
+      rule hour12
+        "0" [1-9] / "10" / "11" / "12" / [1-9]
+      end
+
+      # The numbers 0 through 24 (possibly padded to 2 digits)
+      rule hour24
+        "0" [0-9] / "1" [0-9] / "2" [0-3] / [0-9]
+      end
+
+      # The numbers 0 through 59, always padded to 2 digits.
+      # Used for minutes or seconds.
+      rule int60s
+        first_int60:int60 rest_int60s:(comma_joiner int60)* {
+          def int60s
+            [first_int60] + rest_int60s
+          end
+
+          def rest_int60s
+            super.elements.map{|e| e.int60}
+          end
+
+          def numbers
+            int60s.map{ |n| n.number }
+          end
+        }
+      end
+
+      # The numbers 0 through 59, always padded to 2 digits.
+      # Used for minutes or seconds.
+      rule int60
+        [0-5] [0-9] {
+          def number
+            text_value.to_i
+          end
+        }
+      end
+
+      rule comma_joiner
+        (WS* "," WS* ("and" WS+)? / WS+ "and" WS+)
+      end
+
+      rule comma_or_semicolon_joiner
+        (WS* [,;] WS* ("and" WS+)? / WS+ "and" WS+)
+      end
+
+      # whitespace
+      rule WS
+        [ \t]
+      end
+    end
+  end
+end
+

data/lib/ice_cube/english/schedule_extension.rb

@@ -0,0 +1,44 @@
+require 'treetop'
+require 'ice_cube'
+require 'ice_cube/english/schedule_grammar'
+
+module IceCube
+  module English
+    module ScheduleExtension
+      # Add the specified rule to the Schedule as a recurrence rule.
+      # The rule may be a Rule object, or it may be an english String.
+      def add_recurrence_rule_with_english(rule_or_english)
+        return add_recurrence_rule_without_english(rule_or_english) unless rule_or_english.is_a?(String)
+        rules = ::IceCube::Rule.from_english(rule_or_english, :multiple=>true)
+        rules.each do |rule|
+          add_recurrence_rule(rule)
+        end
+        self
+      end
+
+      # Add the specified rule to the Schedule as a exception rule.
+      # The rule may be a Rule object, or it may be an english String.
+      def add_exception_rule_with_english(rule_or_english)
+        return add_exception_rule_without_english(rule_or_english) unless rule_or_english.is_a?(String)
+        rules = ::IceCube::Rule.from_english(rule_or_english, :multiple=>true)
+        rules.each do |rule|
+          add_exception_rule(rule)
+        end
+        self
+      end
+    end
+  end
+end
+
+class IceCube::Schedule   # reopen
+  include ::IceCube::English::ScheduleExtension
+
+  alias add_recurrence_rule_without_english add_recurrence_rule
+  alias add_recurrence_rule add_recurrence_rule_with_english
+
+  alias add_exception_rule_without_english add_exception_rule
+  alias add_exception_rule add_exception_rule_with_english
+
+  alias rrule add_recurrence_rule
+  alias exrule add_exception_rule
+end

data/lib/ice_cube/english/schedule_grammar.treetop

@@ -0,0 +1,26 @@
+require 'ice_cube/english/rule_grammar'
+
+module IceCube
+  module English
+    grammar ScheduleGrammar
+      include IceCube::English::RuleGrammar
+
+      # Multiple recurrence rules
+      rule recurrence_rules
+        first_rule:recurrence_rule rest_rules:( comma_or_semicolon_joiner recurrence_rule )* "."? {
+          def rules
+            [first_rule] + rest_rules
+          end
+
+          def rest_rules
+            super.elements.map{|r| r.recurrence_rule}
+          end
+
+          def attribute_hashes
+            rules.map{ |r| r.attributes }
+          end
+        }
+      end
+    end
+  end
+end

data/lib/ice_cube/english/version.rb

@@ -0,0 +1,5 @@
+module IceCube
+  module English
+    VERSION = '0.1'
+  end
+end

data/lib/ice_cube_english.rb

@@ -0,0 +1 @@
+require 'ice_cube/english'

data/test/test_helper.rb

@@ -0,0 +1,4 @@
+require 'rubygems'
+$LOAD_PATH.unshift File.expand_path "../../lib", __FILE__
+require 'ice_cube_english'
+require 'test/unit'

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification 
+name: ice_cube_english
+version: !ruby/object:Gem::Version 
+  hash: 9
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  version: "0.1"
+platform: ruby
+authors: 
+- Dwayne Litzenberger
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-30 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: treetop
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 21
+        segments: 
+        - 1
+        - 4
+        - 9
+        version: 1.4.9
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: ice_cube
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 0
+        - 6
+        - 6
+        version: 0.6.6
+  type: :runtime
+  version_requirements: *id002
+description: ice_cube_english provides english time and date parsing for ice_cube.
+email: dlitz@patientway.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- lib/ice_cube/english/grammar_helper.rb
+- lib/ice_cube/english/rule_extension.rb
+- lib/ice_cube/english/schedule_extension.rb
+- lib/ice_cube/english/version.rb
+- lib/ice_cube/english.rb
+- lib/ice_cube_english.rb
+- lib/ice_cube/english/rule_grammar.treetop
+- lib/ice_cube/english/schedule_grammar.treetop
+- README.rdoc
+- test/test_helper.rb
+has_rdoc: true
+homepage: https://github.com/dlitz/ice_cube_english
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 23
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: ice-cube-english
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: English time and date parsing for ice_cube
+test_files: 
+- test/test_helper.rb