texp 0.0.3

data/lib/texp/month.rb

@@ -0,0 +1,32 @@
+module TExp
+  class Month < Base
+    register_parse_callback('m')
+
+    def initialize(months)
+      @months = listize(months)
+    end
+
+    # Is +date+ included in the temporal expression.
+    def include?(date)
+      @months.include?(date.month)
+    end
+
+    # Human readable version of the temporal expression.
+    def inspect
+      "the month is " +
+        humanize_list(@months) { |m| Date::MONTHNAMES[m] }
+    end
+
+    # Encode the temporal expression into +codes+.
+    def encode(codes)
+      encode_list(codes, @months)
+      codes << encoding_token
+    end
+
+    def to_hash
+      build_hash do |b|
+        b.with @months
+      end
+    end
+  end
+end

data/lib/texp/parse.rb

@@ -0,0 +1,112 @@
+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 = {}
+
+    # Lexical Definitions
+    TOKEN_PATTERNS = [
+      # Dates
+      '\d\d\d\d-\d\d-\d\d',
+      # Numbers
+      '[+-]?\d+',
+      # Extension Tokens
+      '<(?:[a-zA-Z_][a-zA-Z0-9_]*::)?[a-zA-Z_][a-zA-Z0-9_]*>',
+      # Everything else is a single character
+      # (except commas and spaces which are ignored)
+      '[^, ]',
+    ].join('|')
+    TOKEN_RE = Regexp.new(TOKEN_PATTERNS)
+
+    # Register a parsing callback.  Individual Temporal Expression
+    # classes will register their won 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
+    def parse(string)
+      @stack = []
+      string.scan(TOKEN_RE) do |tok|
+        compile(tok)
+      end
+      fail ParseError, "Incomplete expression" if @stack.size > 1
+      @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.
+    def compile(tok)
+      handler = PARSE_CALLBACKS[tok]
+      if handler
+        handler.parse_callback(@stack)
+      else
+        case tok
+        when /^\d\d\d\d-\d\d-\d\d/
+          @stack.push Date.parse(tok)
+        when /^[-+]?\d+$/
+          @stack.push tok.to_i
+        else
+          fail ParseError, "Unrecoginized TExp Token '#{tok}'"
+        end
+      end
+    end
+
+  end # << TExp
+
+  # Convenience class for creating parse callbacks.
+  class ParseCallback
+    def initialize(&block)
+      @callback = block
+    end
+    def parse_callback(stack)
+      @callback.call(stack)
+    end
+  end
+  
+  # List parsing handlers
+  
+  MARK = :mark
+  
+  # Push a mark on the stack to start a list.
+  register_parse_callback('[',
+    ParseCallback.new do |stack|
+      stack.push MARK
+    end)
+  
+  # Pop the stack and build a list until you find a mark.
+  register_parse_callback(']',
+    ParseCallback.new do |stack|
+      list = []
+      while ! stack.empty? && stack.last != MARK
+        list.unshift stack.pop
+      end
+      fail ParseError, "Expression stack exhausted" if stack.empty?
+      stack.pop
+      stack.push list
+    end)
+end # module TExp

data/lib/texp/week.rb

@@ -0,0 +1,61 @@
+require 'date'
+
+module TExp
+  class Week < Base
+    register_parse_callback('k')
+
+    def initialize(weeks)
+      @weeks = listize(weeks)
+    end
+
+    # Is +date+ included in the temporal expression.
+    def include?(date)
+      @weeks.include?(week_from_front(date)) ||
+        @weeks.include?(week_from_back(date))
+    end
+
+    # Encode the temporal expression into +codes+.
+    def encode(codes)
+      encode_list(codes, @weeks)
+      codes << encoding_token
+    end
+
+    # Human readable version of the temporal expression.
+    def inspect
+      "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)
+      week = ((date.day-1) / 7) + 1
+    end
+
+    def week_from_back(date)
+      last_day = last_day_of_month(date)
+      -(((last_day - date.day) / 7) + 1)
+    end
+
+    def self.days_in_month(month)
+      d = Date.new(2007, month, 1) + 31
+      while d.day < 27
+        d -= 1
+      end
+      d.day
+    end
+
+    DAYS_IN_MONTH = [ 0 ] +
+      (1..12).collect { |m| days_in_month(m) }
+
+    def last_day_of_month(date)
+      DAYS_IN_MONTH[date.month] +
+        (date.month == 2 && Date.leap?(date.year) ? 1 : 0)
+    end
+  end
+end

data/lib/texp/window.rb

@@ -0,0 +1,52 @@
+module TExp
+  class Window < Base
+    register_parse_callback('s')
+
+    def initialize(texp, prewindow_days, postwindow_days)
+      @texp = 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) }
+    end
+
+    # Human readable version of the temporal expression.
+    def inspect
+      @texp.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)
+      codes << @prewindow_days << "," << @postwindow_days << "s"
+    end
+
+    def to_hash
+      fail "TBD"
+    end
+
+    private
+
+    def days(n)
+      n == 1 ? "#{n} day" : "#{n} days"
+    end
+
+    class << self
+      # Parsing callback for window temporal expressions.
+      def parse_callback(stack)
+        postwindow = stack.pop
+        prewindow = stack.pop
+        te = stack.pop
+        stack.push TExp::Window.new(te, prewindow, postwindow)
+      end
+    end # class << self
+
+  end
+end

data/lib/texp/year.rb

@@ -0,0 +1,31 @@
+module TExp
+  class Year < Base
+    register_parse_callback('y')
+
+    def initialize(years)
+      @years = listize(years)
+    end
+
+    # Is +date+ included in the temporal expression.
+    def include?(date)
+      @years.include?(date.year)
+    end
+
+    # Human readable version of the temporal expression.
+    def inspect
+      "the year is " + humanize_list(@years)
+    end
+
+    # Encode the temporal expression into +codes+.
+    def encode(codes)
+      encode_list(codes, @years)
+      codes << encoding_token
+    end
+    
+    def to_hash
+      build_hash do |b|
+        b.with @years
+      end
+    end
+  end
+end

data/test/texp/day_interval_test.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'date'
+require 'texp'
+
+class DayIntervalTest < Test::Unit::TestCase
+
+  def test_day_interval
+    te = TExp::DayInterval.new(Date.parse("Feb 10, 2008"), 3)
+    assert te.include?(Date.parse("Feb 10, 2008"))
+    assert ! te.include?(Date.parse("Feb 11, 2008"))
+    assert ! te.include?(Date.parse("Feb 12, 2008"))
+    assert te.include?(Date.parse("Feb 13, 2008"))
+    assert ! te.include?(Date.parse("Feb 14, 2008"))
+    assert ! te.include?(Date.parse("Feb 15, 2008"))
+    assert te.include?(Date.parse("Feb 16, 2008"))
+    assert ! te.include?(Date.parse("Feb 17, 2008"))
+    assert ! te.include?(Date.parse("Feb 18, 2008"))
+  end
+end
+

data/test/texp/day_of_month_test.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+
+require 'date'
+require 'test/unit'
+require 'texp'
+
+class DayOfMonthTest < Test::Unit::TestCase
+
+  def test_day_of_month_with_single_arg
+    te = TExp::DayOfMonth.new(14)
+    assert te.include?(Date.parse("Dec 14, 2006"))
+    assert te.include?(Date.parse("Feb 14, 2008"))
+    assert ! te.include?(Date.parse("Feb 15, 2008"))
+  end
+
+  def test_day_of_include_with_one_day
+    te = TExp::DayOfMonth.new([10, 14, 16])
+    assert te.include?(Date.parse("Feb 10, 2008"))
+    assert ! te.include?(Date.parse("Feb 11, 2008"))
+    assert ! te.include?(Date.parse("Feb 12, 2008"))
+    assert ! te.include?(Date.parse("Feb 13, 2008"))
+    assert te.include?(Date.parse("Feb 14, 2008"))
+    assert ! te.include?(Date.parse("Feb 15, 2008"))
+    assert te.include?(Date.parse("Feb 16, 2008"))
+  end
+end
+

data/test/texp/day_of_week_test.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+
+require 'date'
+require 'test/unit'
+require 'texp'
+
+class DayOfWeekTest < Test::Unit::TestCase
+
+  def test_day_of_week_include_with_one_day
+    te = TExp::DayOfWeek.new([1])
+    assert ! te.include?(Date.parse("Feb 10, 2008"))
+    assert te.include?(Date.parse("Feb 11, 2008"))
+    assert ! te.include?(Date.parse("Feb 12, 2008"))
+    assert ! te.include?(Date.parse("Feb 13, 2008"))
+    assert ! te.include?(Date.parse("Feb 14, 2008"))
+    assert ! te.include?(Date.parse("Feb 15, 2008"))
+    assert ! te.include?(Date.parse("Feb 16, 2008"))
+  end
+
+  def test_day_of_week_include_with_several_days
+    te = TExp::DayOfWeek.new([1, 3, 5])
+    assert ! te.include?(Date.parse("Feb 10, 2008"))
+    assert te.include?(Date.parse("Feb 11, 2008"))
+    assert ! te.include?(Date.parse("Feb 12, 2008"))
+    assert te.include?(Date.parse("Feb 13, 2008"))
+    assert ! te.include?(Date.parse("Feb 14, 2008"))
+    assert te.include?(Date.parse("Feb 15, 2008"))
+    assert ! te.include?(Date.parse("Feb 16, 2008"))
+  end
+end
+

data/test/texp/every_day_test.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'date'
+
+require 'texp'
+
+class EveryDayTest < Test::Unit::TestCase
+
+  def test_every_day
+    te = TExp::EveryDay.new
+    assert te.include?(Date.parse("Feb 15, 2008"))
+  end
+end
+

data/test/texp/ext_test.rb

@@ -0,0 +1,82 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'date'
+require 'texp'
+
+module TExp
+
+  # Extensions is the standard module for TExp extensions.
+  module Extensions
+
+    # You should put your extensions inside your own namespace module.
+    # This will help avoid collisions with with other extensions.
+    module MyExt
+
+      # Create a Temporal Expression class.  Inheriting from
+      # TExp::Base allows you to reuse some common functionality
+      # defined there.  Other choices are:
+      #
+      # (1) TExp::TermsBase -- Defines a parsing method for handling
+      #     lists of temporal expressions as argument lists.
+      #
+      class Never < Base
+
+        # Register your parsing token.  Include your namespace as part
+        # of the token to avoid naming collisions with other
+        # extensions.
+        register_parse_callback("<MyExt::never>")
+
+        # Define how your temporal expression class handles dates.
+        # Our example is easy because we always return false.
+        def include?(date)
+          false
+        end
+
+        # Define an encoder for your temporal expression.  Your
+        # encoder should push tokens onto +codes+ in a manner that
+        # your +parse_handler+ can handle them.  Remember that the
+        # temporal expressions mini-language is a stack machine that
+        # pushs arguments onto the stack before your parse handler
+        # sees them.
+        def encode(codes)
+          codes << "<MyExt::never>"
+        end
+
+        class << self
+          # Define a parse handler that will handle your registered
+          # parse token.  At the point the handler is called,
+          # arguments will have been pushed onto the stack.  All you
+          # have to do is pop them off, construct your temporal
+          # expression and push it back onto the stack.
+          #
+          # See TExp::DayInterval for an example of an expression that
+          # handle arguments.
+          #
+          def parse_callback(stack)
+            stack.push new
+          end
+        end
+      end
+
+    end # module MyExt
+
+  end # module Extensions
+end # module TExp
+
+class ExtensionsTest < Test::Unit::TestCase
+  def test_never
+    te = TExp::Extensions::MyExt::Never.new
+    assert ! te.include?(Date.today)
+  end
+
+  def test_parse_never
+    te = TExp.parse("<MyExt::never>")
+    assert ! te.include?(Date.today)
+  end
+
+  def test_parsing_round_trip
+    assert_equal "<MyExt::never>", TExp.parse("<MyExt::never>").to_s
+  end
+end
+