texp 0.0.3 → 0.0.7

data/lib/texp/every_day.rb

@@ -3,7 +3,7 @@ module TExp
     register_parse_callback('e')
 
     # Is +date+ included in the temporal expression.
-    def include?(date)
+    def includes?(date)
       true
     end
 
@@ -17,10 +17,6 @@ module TExp
       codes << encoding_token
     end
 
-    def to_hash
-      build_hash
-    end
-
     class << self
       def parse_callback(stack)
         stack.push TExp::EveryDay.new

data/lib/texp/logic.rb

@@ -1,31 +1,14 @@
 module TExp
 
-  # Base class for temporal expressions with multiple sub-expressions
-  # (i.e. terms).
-  class TermsBase < Base
-    class << self
-      # Parsing callback for terms based temporal expressions.  The
-      # top of the stack is assumed to be a list that is *-expanded to
-      # the temporal expression's constructor.
-      def parse_callback(stack)
-        stack.push self.new(*stack.pop)
-      end
-    end
-  end
-
+  ####################################################################
   # Logically AND a list of temporal expressions.  A date is included
   # only if it is included in all of the sub-expressions.
-  class And < TermsBase
+  class And < MultiTermBase
     register_parse_callback('a')
 
-    # Create an AND temporal expression.
-    def initialize(*terms)
-      @terms = terms
-    end
-
     # Is +date+ included in the temporal expression.
-    def include?(date)
-      @terms.all? { |te| te.include?(date) }
+    def includes?(date)
+      @terms.all? { |te| te.includes?(date) }
     end
 
     # Human readable version of the temporal expression.
@@ -38,21 +21,17 @@ module TExp
       encode_list(codes, @terms)
       codes << encoding_token
     end
-  end
+  end # class And
 
+  ####################################################################
   # Logically OR a list of temporal expressions.  A date is included
   # if it is included in any of the sub-expressions.
-  class Or < TermsBase
+  class Or < MultiTermBase
     register_parse_callback('o')
 
-    # Create an OR temporal expression.
-    def initialize(*terms)
-      @terms = terms
-    end
-
     # Is +date+ included in the temporal expression.
-    def include?(date)
-      @terms.any? { |te| te.include?(date) }
+    def includes?(date)
+      @terms.any? { |te| te.includes?(date) }
     end
 
     # Human readable version of the temporal expression.
@@ -65,21 +44,17 @@ module TExp
       encode_list(codes, @terms)
       codes << encoding_token
     end
-  end
+  end # class Or
 
+  ####################################################################
   # Logically NEGATE a temporal expression.  A date is included if it
   # is not included in the sub-expression.
-  class Not < Base
+  class Not < SingleTermBase
     register_parse_callback('n')
 
-    # Create a NOT temporal expression.
-    def initialize(term)
-      @term = term
-    end
-
     # Is date included in the temporal expression.
-    def include?(date)
-      ! @term.include?(date)
+    def includes?(date)
+      ! @term.includes?(date)
     end
 
     # Human readable version of the temporal expression.
@@ -92,5 +67,6 @@ module TExp
       @term.encode(codes)
       codes << encoding_token
     end
-  end
+  end # class Not
+  
 end

data/lib/texp/month.rb

@@ -7,7 +7,7 @@ module TExp
     end
 
     # Is +date+ included in the temporal expression.
-    def include?(date)
+    def includes?(date)
       @months.include?(date.month)
     end
 
@@ -23,10 +23,5 @@ module TExp
       codes << encoding_token
     end
 
-    def to_hash
-      build_hash do |b|
-        b.with @months
-      end
-    end
   end
 end

data/lib/texp/operators.rb

@@ -0,0 +1,53 @@
+module TExp
+  class Base
+
+    # Combine two temporal expressions so that the result will match
+    # the union of the dates matched by the individual temporal
+    # expressions.
+    #
+    # <b>Examples:</b>
+    #
+    #    dow(:monday) + dow(:tuesday) # Match any date falling on Monday or Tuesday
+    #
+    def +(texp)
+      TExp::Or.new(self, texp)
+    end
+
+    # Combine two temporal expressions so that the result will match
+    # the intersection of the dates matched by the individual temporal
+    # expressions.
+    #
+    # <b>Examples:</b>
+    #
+    #    month("Feb") * day(14) # Match the 14th of February (in any year)
+    #
+    def *(texp)
+      TExp::And.new(self, texp)
+    end
+
+    # Combine two temporal expressions so that the result will match
+    # the any date matched by left expression except for dates matched
+    # by the right expression.
+    #
+    # <b>Examples:</b>
+    #
+    #    month("Feb") - dow(:mon)    # Match any day in February except Mondays
+    #
+    def -(texp)
+      TExp::And.new(self, TExp::Not.new(texp))
+    end
+
+    # Return a new temporal expression that negates the sense of the
+    # current expression.  In other words, match everything the
+    # current expressions does not match and don't match anything that
+    # it does.
+    #
+    # <b>Examples:</b>
+    #
+    #    -dow(:mon)    # Match everything but Mondays
+    #    
+    def -@()
+      TExp::Not.new(self)
+    end
+  end
+end

data/lib/texp/parse.rb

@@ -1,15 +1,10 @@
 module TExp
 
-  # Thrown if an error is encountered during the parsing of a temporal
-  # expression.
-  class ParseError < StandardError
-  end
-
   # ------------------------------------------------------------------
   # Class methods.
   #
   class << self
-    PARSE_CALLBACKS = {}
+    PARSE_CALLBACKS = {}        # :nodoc:
 
     # Lexical Definitions
     TOKEN_PATTERNS = [
@@ -22,17 +17,17 @@ module TExp
       # Everything else is a single character
       # (except commas and spaces which are ignored)
       '[^, ]',
-    ].join('|')
-    TOKEN_RE = Regexp.new(TOKEN_PATTERNS)
+    ].join('|')                           # :nodoc:
+    TOKEN_RE = Regexp.new(TOKEN_PATTERNS) # :nodoc:
 
     # Register a parsing callback.  Individual Temporal Expression
-    # classes will register their won callbacks as needed.  A handful
+    # classes will register their own callbacks as needed.  A handful
     # of non-class based parser callbacks are registered below.
     def register_parse_callback(token, callback)
       PARSE_CALLBACKS[token] = callback
     end
   
-    # Parse a temporal expression string
+    # Return the temporal expression encoded by string.
     def parse(string)
       @stack = []
       string.scan(TOKEN_RE) do |tok|
@@ -42,21 +37,6 @@ module TExp
       @stack.pop
     end
 
-    def from_params(hash)
-      h = hash['1']
-      tok = h['type']
-      cb = PARSE_CALLBACKS[tok]
-      a1 = h["#{tok}1"]
-      a2 = h["#{tok}2"]
-      if a2
-        cb.new(a1, a2)
-      elsif a1
-        cb.new(a1)
-      else
-        cb.new
-      end
-    end
-    
     private
 
     # Compile the token into the current definition.
@@ -90,7 +70,8 @@ module TExp
   
   # List parsing handlers
   
-  MARK = :mark
+  # Mark the end of the list.
+  MARK = :mark                  # :nodoc:
   
   # Push a mark on the stack to start a list.
   register_parse_callback('[',
@@ -108,5 +89,6 @@ module TExp
       fail ParseError, "Expression stack exhausted" if stack.empty?
       stack.pop
       stack.push list
-    end)
+    end
+    )
 end # module TExp

data/lib/texp/time_ext.rb

@@ -0,0 +1,7 @@
+class Time
+  unless Time.now.respond_to?(:to_date)
+    def to_date
+      Date.new(self.year, self.month, self.day)
+    end
+  end
+end

data/lib/texp/version.rb

@@ -0,0 +1,3 @@
+module TExp
+  VERSION = '0.0.7'
+end

data/lib/texp/week.rb

@@ -9,7 +9,7 @@ module TExp
     end
 
     # Is +date+ included in the temporal expression.
-    def include?(date)
+    def includes?(date)
       @weeks.include?(week_from_front(date)) ||
         @weeks.include?(week_from_back(date))
     end
@@ -25,12 +25,6 @@ module TExp
       "it is the " + ordinal_list(@weeks) + " week of the month"
     end
 
-    def to_hash
-      build_hash do |b|
-        b.with @weeks
-      end
-    end
-
     private
 
     def week_from_front(date)

data/lib/texp/window.rb

@@ -1,37 +1,55 @@
 module TExp
-  class Window < Base
+  class Window < SingleTermBase
     register_parse_callback('s')
 
     def initialize(texp, prewindow_days, postwindow_days)
-      @texp = texp
+      super(texp)
       @prewindow_days = prewindow_days
       @postwindow_days = postwindow_days      
     end
 
     # Is +date+ included in the temporal expression.
-    def include?(date)
-      @texp.include?(date) ||
-        (1..@prewindow_days).any? { |i| @texp.include?(date + i) } ||
-        (1..@postwindow_days).any? { |i| @texp.include?(date - i) }
+    def includes?(date)
+      find_pivot(date) != nil
+    end
+
+    # Return the first day of the window for a given date.  Return nil
+    # if the date is not in a window.
+    def first_day_of_window(date)
+      pivot = find_pivot(date)
+      pivot ? pivot - @prewindow_days : nil
+    end
+
+    # Return the first day of the window for a given date.  Return nil
+    # if the date is not in a window.
+    def last_day_of_window(date)
+      pivot = find_pivot(date)
+      pivot ? pivot + @postwindow_days : nil
+    end
+
+    # Find the matching date for the window.
+    def find_pivot(date)
+      d = date - @postwindow_days
+      while d <= date + @prewindow_days
+        return d if @term.includes?(d)
+        d += 1
+      end
+      return nil
     end
 
     # Human readable version of the temporal expression.
     def inspect
-      @texp.inspect + ", " +
+      @term.inspect + ", " +
         "or up to #{days(@prewindow_days)} prior, " +
         "or up to #{days(@postwindow_days)} after"
     end
 
     # Encode the temporal expression into +codes+.
     def encode(codes)
-      @texp.encode(codes)
+      @term.encode(codes)
       codes << @prewindow_days << "," << @postwindow_days << "s"
     end
 
-    def to_hash
-      fail "TBD"
-    end
-
     private
 
     def days(n)

data/lib/texp/year.rb

@@ -7,7 +7,7 @@ module TExp
     end
 
     # Is +date+ included in the temporal expression.
-    def include?(date)
+    def includes?(date)
       @years.include?(date.year)
     end
 
@@ -22,10 +22,5 @@ module TExp
       codes << encoding_token
     end
     
-    def to_hash
-      build_hash do |b|
-        b.with @years
-      end
-    end
   end
 end

data/test/texp/base_test.rb

@@ -0,0 +1,82 @@
+require 'test/unit'
+require 'texp'
+
+class BaseEachTest < Test::Unit::TestCase
+  def test_each_on_base
+    te = basic_texp
+    assert_equal [te], te.collect { |t| t }
+  end
+
+  def test_each_on_single_term
+    te = single_term_texp
+    assert_equal [@basic, @single], te.collect { |t| t }
+  end
+
+  def test_each_on_multi_term
+    te = multi_term_texp
+    assert_equal [@basic, @multi], te.collect { |t| t }
+  end
+
+  private
+
+  def basic_texp
+    @basic = TExp::DayOfMonth.new(1)
+  end
+
+  def single_term_texp
+    @single = TExp::Not.new(basic_texp)
+  end
+
+  def multi_term_texp
+    @multi = TExp::And.new(basic_texp)
+  end
+
+end
+
+class BaseAnchorTest < Test::Unit::TestCase
+  def test_setting_anchor_date
+    start_date = Date.parse("Feb 10, 2008")
+    te = TExp::DayInterval.new(start_date, 3)
+    assert_cycle(te, start_date, 3)
+
+    te2 = te.reanchor(start_date+1)
+
+    assert_cycle(te, start_date, 3)
+    assert_cycle(te2, start_date+1, 3)
+  end
+
+  def assert_cycle(te, start_date, n)
+    (0...2*n).each do |i|
+      if (i % n) == 0
+        assert te.includes?(start_date + i)
+      else
+        assert ! te.includes?(start_date + i)
+      end
+    end
+  end
+
+  def test_that_complex_expression_propagate_anchor_date
+    start_date = Date.parse("Feb 14, 2008")
+    two_day_cycle = TExp::DayInterval.new(start_date, 2)
+    three_day_cycle = TExp::DayInterval.new(start_date, 3)
+    year_2008 = TExp::Year.new(2008)
+
+    te = TExp::And.new(
+      year_2008,
+      TExp::Or.new(two_day_cycle, TExp::Not.new(three_day_cycle)))
+
+    new_date = Date.parse("Feb 15, 2008")
+    te2 = te.reanchor(new_date)
+
+    assert_complex_cycle(te, start_date)
+    assert_complex_cycle(te2, new_date)
+  end
+
+  def assert_complex_cycle(te, start_date)
+    assert te.includes?(start_date)
+    assert te.includes?(start_date+1)
+    assert te.includes?(start_date+2)
+    assert ! te.includes?(start_date+3)
+    assert te.includes?(start_date+4)
+  end
+end