temporals 2.0.0 → 2.0.1

data/lib/temporals.rb

@@ -7,7 +7,7 @@ require 'temporals/patterns'
 require 'temporals/parser'
 
 class Temporal
-  VERSION = '2.0.0'
+  VERSION = '2.0.1'
 
   def initialize(options)
     options.each do |key,value|
@@ -44,14 +44,14 @@ class Temporal
   def occurs_on_day?(datetime)
     puts "#{datetime} IN? #{inspect}" if $DEBUG
     if @type =~ /month/
-      puts "Month #{Month.order[datetime.month-1].inspect} == #{@month.inspect} >> #{Month.order[datetime.month-1].value_in?(@month)}" if $DEBUG
-      return false unless Month.order[datetime.month-1].value_in?(@month)
+      puts "Month #{Month.new(datetime.month-1).inspect} in? #{@month.inspect} >> #{Month.new(datetime.month-1).value_in?(@month)}" if $DEBUG
+      return false unless Month.new(datetime.month-1).value_in?(@month)
     end
     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
-      puts "WeekdayLast: #{datetime.wday_last} in? #{@ord.inspect} == #{datetime.wday_last.value_in?(@ord)}" if $DEBUG
+      puts "Weekday: #{WDay.new(datetime.wday).inspect} in? #{@wday.inspect} >> #{WDay.new(datetime.wday).value_in?(@wday)}" if $DEBUG
+      return false unless WDay.new(datetime.wday).value_in?(@wday)
+      puts "WeekdayOrd: #{datetime.wday_ord} in? #{@ord.inspect} >> #{datetime.wday_ord.value_in?(@ord)}" if $DEBUG
+      puts "WeekdayLast: #{datetime.wday_last} in? #{@ord.inspect} >> #{datetime.wday_last.value_in?(@ord)}" if $DEBUG
       return false unless datetime.wday_ord.value_in?(@ord) || datetime.wday_last.value_in?(@ord)
     end
     if @type =~ /month_ord/
@@ -63,8 +63,8 @@ class Temporal
       return false unless datetime.year.value_in?(@year)
     end
     if @type =~ /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 "Weekday: #{WDay.new(datetime.wday).inspect} in? #{@wday.inspect} == #{WDay.new(datetime.wday).value_in?(@wday)}" if $DEBUG
+      return false unless WDay.new(datetime.wday).value_in?(@wday)
     end
     puts "Occurs on #{datetime}!" if $DEBUG
     return true
@@ -114,3 +114,5 @@ class Temporal
     }.join(' ')
   end
 end
+
+Temporals = Temporal

data/lib/temporals/parser.rb

@@ -1,140 +1,175 @@
 class Temporal
-  class << self
-    def parse(expression)
-      puts "Parsing expression: #{expression.inspect}" if $DEBUG
-      # 1. Normalize the expression
-      # TODO: re-create normalize: ' -&| ', 'time-time'
-      expression.gsub!(/\s+/,' ').gsub!(/([\-\&\|])/,' \1 ')
-      expression.gsub!(/(#{TimeRegexp}?) +- +(#{TimeRegexp})/,'\1-\2')
-      expression.gsub!(/in ([09]\d|\d{4})/) {|s|
-        y = $1
-        y.length == 2 ? (y =~ /^0/ ? '20'+y : '19'+y) : y
-      }
-      expression.gsub!(/(^| )(#{TimeRegexp})( |$)/i) {|s|
-        b = $1
-        time = $2
-        a = $3
-        if s =~ /[:m]/ # If it really looks like a lone piece of time, it'll have either a am/pm or a ':' in it.
-          # Converting a floating time into a timerange that spans the appropriate duration
-          puts "Converting Time to TimeRange: #{time.inspect}" if $DEBUG
-          # Figure out what precision we're at
-          newtime = time + '-'
-          if time =~ /(\d+):(\d+)([ap]m?|$)?/
-            end_hr = $1.to_i
-            end_mn = $2.to_i + 1
-            if end_mn > 59
-              end_mn -= 60
-              end_hr += 1
+  class Parser
+    def initialize(expression)
+      # Make a copy of the passed in string, rather than mutate it
+      @expression = expression.to_s.dup
+    end
+
+    def normalized
+      @normalized || begin
+        normalized = @expression.dup
+        # 1. Normalize the expression
+        # TODO: re-create normalize: ' -&| ', 'time-time'
+        normalized.gsub!(/[\s+,]/,' ')
+        # Pad special characters with spaces for now
+        normalized.gsub!(/([\-\&\|])/,' \1 ')
+        # Get rid of spaces between time ranges
+        normalized.gsub!(/(#{TimeRegexp}?) +(?:-+|to) +(#{TimeRegexp})/,'\1-\2')
+        # Normalize to 4-digit years
+        normalized.gsub!(/in ([09]\d|\d{4})/) {|s|
+          y = $1
+          y.length == 2 ? (y =~ /^0/ ? '20'+y : '19'+y) : y
+        }
+        # Normalize expressions of time
+        normalized.gsub!(/(^| )(#{TimeRegexp})( |$)/i) {|s|
+          b = $1
+          time = $2
+          a = $3
+          if s =~ /[:m]/ # If it really looks like a lone piece of time, it'll have either a am/pm or a ':' in it.
+            # Converting a floating time into a timerange that spans the appropriate duration
+            puts "Converting Time to TimeRange: #{time.inspect}" if $DEBUG
+            # Figure out what precision we're at
+            newtime = time + '-'
+            if time =~ /(\d+):(\d+)([ap]m?|$)?/
+              end_hr = $1.to_i
+              end_mn = $2.to_i + 1
+              if end_mn > 59
+                end_mn -= 60
+                end_hr += 1
+              end
+              end_hr -= 12 if end_hr > 12
+              newtime += "#{end_hr}:#{end_mn}#{$3}" # end-time is 1 minute later
+            elsif time =~ /(\d+)([ap]m?|$)?/
+              end_hr = $1.to_i + 1
+              end_hr -= 12 if end_hr > 12
+              newtime += "#{end_hr}#{$2}" # end-time is 1 hour later
             end
-            end_hr -= 12 if end_hr > 12
-            newtime += "#{end_hr}:#{end_mn}#{$3}" # end-time is 1 minute later
-          elsif time =~ /(\d+)([ap]m?|$)?/
-            end_hr = $1.to_i + 1
-            end_hr -= 12 if end_hr > 12
-            newtime += "#{end_hr}#{$2}" # end-time is 1 hour later
+            puts "Converted! #{newtime}" if $DEBUG
+            b+newtime+a
+          else
+            s
           end
-          puts "Converted! #{newtime}" if $DEBUG
-          b+newtime+a
-        else
-          s
-        end
-      }
-      puts "Normalized expression: #{expression.inspect}" if $DEBUG
+        }
+        puts "Normalized expression: #{normalized.inspect}" if $DEBUG
+        @normalized = normalized
+      end
+    end
 
-      # 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[:word_ord]
-          ord = WordOrds.include?(word.downcase) ? WordOrds.index(word.downcase)+1 : 'last'
-          puts "WordOrd: #{ord}" if $DEBUG
-          {:type => 'ord', :ord => ord}
-        when WordTypes[:wday]
-          {:type => 'wday', :wday => WDay.normalize($1)}
-        when WordTypes[:year]
-          {:type => 'year', :year => word}
-        when WordTypes[:month]
-          {:type => 'month', :month => Month.normalize(word)}
-        when WordTypes[:union]
-          {:type => 'union'}
-        when WordTypes[:range]
-          {:type => 'range'}
-        when WordTypes[:timerange]
-          # determine and inject am/pm
-          start_at = $1
-          end_at = $2
-          start_at_p = $1 if start_at =~ /([ap])m?$/
-          end_at_p = $1 if end_at =~ /([ap])m?$/
-          start_hr = start_at.split(/:/)[0].to_i
-            start_hr = '0' if start_hr == '12' # this is used only for > & < comparisons, so converting it to 0 makes everything easier.
-          end_hr = end_at.split(/:/)[0].to_i
-          if start_at_p && !end_at_p
-            # If end-time is a lower hour number than start-time, then we've crossed noon or midnight, and the end-time a/pm should be opposite.
-            end_at = end_at + (start_hr <= end_hr ? start_at_p : (start_at_p=='a' ? 'p' : 'a'))
-          elsif end_at_p && !start_at_p
-            # If end-time is a lower hour number than start-time, then we've crossed noon or midnight, and the start-time a/pm should be opposite.
-            start_at = start_at + (start_hr <= end_hr ? end_at_p : (end_at_p=='a' ? 'p' : 'a'))
-          elsif !end_at_p && !start_at_p
-            # If neither had am/pm attached, assume am if after 7, pm if 12 or before 7.
-            start_at_p = (start_hr < 8 ? 'p' : 'a')
-            start_at = start_at + start_at_p
-            # If end-time is a lower hour number than start-time, then we've crossed noon or midnight, and the end-time a/pm should be opposite.
-            end_at = end_at + (start_hr <= end_hr ? start_at_p : (start_at_p=='a' ? 'p' : 'a'))
+    def tokenized
+      @tokenized || begin
+        # 2. Tokenize distinct pieces (words) in the expression
+        words = normalized.split(/\s+/)
+        puts words.inspect if $DEBUG
+        tokenized = words.inject([]) do |a,word|
+          a << case word
+          when WordTypes[:ord]
+            {:type => 'ord', :ord => $1}
+          when WordTypes[:word_ord]
+            ord = WordOrds.include?(word.downcase) ? WordOrds.index(word.downcase)+1 : 'last'
+            puts "WordOrd: #{ord}" if $DEBUG
+            {:type => 'ord', :ord => ord}
+          when WordTypes[:wday]
+            {:type => 'wday', :wday => WDay.new($1)}
+          when WordTypes[:year]
+            {:type => 'year', :year => word}
+          when WordTypes[:month]
+            {:type => 'month', :month => Month.new(word)}
+          when WordTypes[:union]
+            {:type => 'union'}
+          when WordTypes[:range]
+            {:type => 'range'}
+          when WordTypes[:timerange]
+            # determine and inject am/pm
+            start_at = $1
+            end_at = $2
+            start_at_p = $1 if start_at =~ /([ap])m?$/
+            end_at_p = $1 if end_at =~ /([ap])m?$/
+            start_hr = start_at.split(/:/)[0].to_i
+              start_hr = '0' if start_hr == '12' # this is used only for > & < comparisons, so converting it to 0 makes everything easier.
+            end_hr = end_at.split(/:/)[0].to_i
+            if start_at_p && !end_at_p
+              # If end-time is a lower hour number than start-time, then we've crossed noon or midnight, and the end-time a/pm should be opposite.
+              end_at = end_at + (start_hr <= end_hr ? start_at_p : (start_at_p=='a' ? 'p' : 'a'))
+            elsif end_at_p && !start_at_p
+              # If end-time is a lower hour number than start-time, then we've crossed noon or midnight, and the start-time a/pm should be opposite.
+              start_at = start_at + (start_hr <= end_hr ? end_at_p : (end_at_p=='a' ? 'p' : 'a'))
+            elsif !end_at_p && !start_at_p
+              # If neither had am/pm attached, assume am if after 7, pm if 12 or before 7.
+              start_at_p = (start_hr < 8 ? 'p' : 'a')
+              start_at = start_at + start_at_p
+              # If end-time is a lower hour number than start-time, then we've crossed noon or midnight, and the end-time a/pm should be opposite.
+              end_at = end_at + (start_hr <= end_hr ? start_at_p : (start_at_p=='a' ? 'p' : 'a'))
+            end
+            start_at += 'm' unless start_at =~ /m$/
+            end_at += 'm' unless end_at =~ /m$/
+            {:type => 'timerange', :start_time => start_at, :end_time => end_at}
           end
-          start_at += 'm' unless start_at =~ /m$/
-          end_at += 'm' unless end_at =~ /m$/
-          {:type => 'timerange', :start_time => start_at, :end_time => end_at}
-        end
-      end.compact
-      def analyzed_expression.collect_types
-        collect {|e|
-          puts "E: #{e.inspect}" if $DEBUG
-          e[:type]
-          }
+        end.compact
+        @tokenized = tokenized
       end
+    end
+
+    def language_patterns_combined
+      @language_patterns_combined || begin
+        language_patterns_combined = tokenized.dup
 
-      # 3. Combine common patterns
-      puts analyzed_expression.inspect if $DEBUG
-      puts analyzed_expression.collect_types.inspect if $DEBUG
+        # 3. Combine common language patterns
+        puts language_patterns_combined.inspect if $DEBUG
+        puts language_patterns_combined.collect {|e| e[:type] }.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)
+        something_was_modified = true
+        while something_was_modified
+          something_was_modified = false
+          before_length = language_patterns_combined.length
+          CommonPatterns.each do |pattern|
+            while i = language_patterns_combined.collect {|e| e[:type] }.includes_sequence?(pattern.split(/ /))
+              CommonPatternActions[pattern].call(language_patterns_combined,i)
+            end
           end
+          after_length = language_patterns_combined.length
+          something_was_modified = true if before_length != after_length
         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] = Temporal.new(analyzed_expression[i]) unless analyzed_expression[i][:type].in?('union', 'range')
+        puts language_patterns_combined.inspect if $DEBUG
+        puts language_patterns_combined.collect {|e| e[:type] }.inspect if $DEBUG
+      
+        @language_patterns_combined = language_patterns_combined
       end
+    end
+
+    def yielded
+      # Binds it all together into a Set or a Union object
+      @yielded || begin
+
+        yielded = language_patterns_combined.dup
 
-      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
+        # What remains should be simply sections of Set logic
+        # 4. Parse Set logic
+        yielded.each_index do |i|
+          yielded[i] = Temporal.new(yielded[i]) unless yielded[i][:type].in?('union', 'range')
+        end
+
+        BooleanPatterns.each do |pattern|
+          while i = yielded.collect {|e| e[:type] }.includes_sequence?(pattern.split(/ /))
+            BooleanPatternActions[pattern].call(yielded,i)
+            break if yielded.length == 1
+          end
         end
-      end
 
-      # This is how we know if the expression couldn't quite be figured out. It should have been condensed down to a single Temporal or Temporal::Set
-      if analyzed_expression.length > 1
-        raise RuntimeError, "Could not parse Temporal Expression: check to make sure it is clear and has only one possible meaning."
+        # This is how we know if the expression couldn't quite be figured out. It should have been condensed down to a single Temporal or Temporal::Set
+        if yielded.length > 1
+          raise RuntimeError, "Could not parse Temporal Expression: check to make sure it is clear and has only one possible meaning to an English-speaking person."
+        end
+
+        @yielded = yielded[0]
       end
+    end
+  end
 
-      return analyzed_expression[0]
+  class << self
+    def parse(expression)
+      puts "Parsing expression: #{expression.inspect}" if $DEBUG
+      Temporal::Parser.new(expression).yielded
     end
   end
 end

data/lib/temporals/patterns.rb

@@ -96,7 +96,9 @@ class Temporal
       words.slice!(i+1,2)
     },
     'month range month' => lambda {|words,i|
-      raise "Not Implemented Yet!"
+      # raise "Not Implemented Yet!"
+      words[i][:month] = (words[i][:month]..words[i+2][:month])
+      words.slice!(i+1,2)
     },
     'ord_wday month' => lambda {|words,i|
       words[i][:type] = 'ord_wday_month'

data/lib/temporals/ruby_ext.rb

@@ -13,12 +13,13 @@ class Array
     any? do |iv|
       case iv
       when Range || Array
-        v.to_i.in?(iv)
+        v.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
+          puts "Comparing #{iv} with #{v}" if $DEBUG
+          iv == v
         end
       end
     end

data/lib/temporals/types.rb

@@ -23,6 +23,22 @@ class Temporal
         order.include?(word) ? word : (translations.has_key?(word) ? translations[word] : nil)
       end
     end
+
+    attr_reader :name, :ord
+    alias :to_s :name
+    alias :inspect :to_s
+
+    def initialize(word)
+      @name = word.is_a?(String) ? self.class.normalize(word) : self.class.order[word]
+      @ord  = self.class.order.index(@name)
+    end
+
+    def <=>(other)
+      ord <=> other.ord
+    end
+    def ==(other)
+      ord == other.ord && name == other.name
+    end
   end
 
   class WDay < Classification

data/spec/temporals_spec.rb

@@ -2,7 +2,21 @@ require 'rubygems'
 require 'spec'
 require File.dirname(__FILE__) + '/../lib/temporals'
 
+describe Temporal::Parser do
+  it "should not modify the string passed in" do
+    s = "2pm Tuesdays"
+    Temporal.parse(s)
+    s.should == "2pm Tuesdays"
+  end
+end
+
 describe Temporal do
+  it "Thursday" do
+    t = Temporal.parse('Thursday')
+    t.should_not be_nil
+    t.to_natural.should eql('Thursday')
+  end
+  
   it "1st-2nd and last Thursdays of March and April 5-6:30pm and March 16th - 24th at 2-2:30pm" do
     t = Temporal.parse("1st-2nd and last Thursdays of March and April 5-6:30pm and March 16th - 24th at 2-2:30pm")
     t.include?(Time.parse('2009-03-05 17:54')).should eql(true)
@@ -48,7 +62,7 @@ describe Temporal do
       #  (1st Thursdays at 4-5pm) and ((First - Fourth of March and April) at 2-3:30pm)
       #  (1st Thursdays at 4-5pm) and (First - Fourth of March) and (April at 2-3:30pm)
       Temporal.parse("1st Thursdays at 4-5pm and First - Fourth of March and April at 2-3:30pm")
-    }.should raise_error(RuntimeError, "Could not parse Temporal Expression: check to make sure it is clear and has only one possible meaning.")
+    }.should raise_error(RuntimeError, "Could not parse Temporal Expression: check to make sure it is clear and has only one possible meaning to an English-speaking person.")
   end
 
   it "2pm Tuesdays" do
@@ -100,4 +114,18 @@ describe Temporal do
     t.include?(Time.parse('2009-01-09 2:14pm')).should eql(true)
     t.include?(Time.parse('2009-01-09 3:14pm')).should eql(false)
   end
+  
+  it "should parse '2009'" do
+    t = Temporal.parse("2009")
+    t.occurs_on_day?(Date.parse("January 15, 2009")).should eql(true)
+    t.include?(Time.parse('2009-01-09 2:14pm')).should eql(true)
+    t.include?(Time.parse('2009-01-09 3:14pm')).should eql(true)
+    t.occurs_on_day?(Date.parse("August 20, 2010")).should eql(false)
+  end
+
+  it "should parse '2-4pm Tuesdays and Thursdays, March through June'" do
+    t = Temporal.parse("2-4pm Tuesdays and Thursdays, March through June")
+    t.include?(Time.parse('2010-03-02 2:10pm')).should eql(true)
+    t.include?(Time.parse('2010-02-02 2:10pm')).should eql(false)
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: temporals
 version: !ruby/object:Gem::Version 
-  version: 2.0.0
+  version: 2.0.1
 platform: ruby
 authors: 
 - Daniel Parker
@@ -30,7 +30,7 @@ cert_chain:
   teST6sOe8lUhZQ==
   -----END CERTIFICATE-----
 
-date: 2009-11-21 00:00:00 -05:00
+date: 2010-02-12 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency