texp 0.0.3

data/lib/texp.rb

@@ -0,0 +1,13 @@
+require 'texp/core'
+require 'texp/base'
+require 'texp/parse'
+require 'texp/day_of_week'
+require 'texp/day_of_month'
+require 'texp/week'
+require 'texp/month'
+require 'texp/year'
+require 'texp/day_interval'
+require 'texp/every_day'
+require 'texp/window'
+require 'texp/logic'
+require 'texp/ext'

data/lib/texp/base.rb

@@ -0,0 +1,146 @@
+require 'texp/hash_builder'
+
+module TExp
+  # Abstract Base class for all Texp Temporal Expressions.
+  class Base
+
+    # Convert the temporal expression into an encoded string (that can
+    # be parsed by TExp.parse).
+    def to_s
+      codes = []
+      encode(codes)
+      codes.join("")
+    end
+
+    private
+
+    # Coerce +arg+ into a list (i.e. Array) if it is not one already.
+    def listize(arg)
+      case arg
+      when Array
+        arg
+      else
+        [arg]
+      end
+    end
+
+    # Encode the date into the codes receiver.
+    def encode_date(codes, date)
+      codes << date.strftime("%Y-%m-%d")
+    end
+
+    # Encode the list into the codes receiver.  All
+    def encode_list(codes, list)
+      if list.empty?
+        codes << "[]"
+      elsif list.size == 1
+        codes << list.first
+      else
+        codes << "["
+        prev = nil
+        list.each do |item|
+          codes << "," if prev && ! prev.kind_of?(TExp::Base)
+          codes << item.to_s
+          prev = item
+        end
+        codes << "]"
+      end
+    end
+
+    # For the list of integers as a list of ordinal numbers.  By
+    # default, use 'or' as a connectingin word. (e.g. [1,2,3] => "1st,
+    # 2nd, or 3rd")
+    def ordinal_list(list, connector='or')
+      humanize_list(list, connector) { |item| ordinal(item) }
+    end
+
+    # Format the list in a human readable format.  By default, use
+    # "or" as a connecting word. (e.g. ['a', 'b', 'c'] => "a, b, or
+    # c")
+    def humanize_list(list, connector='or', &block)
+      block ||= lambda { |item| item.to_s }
+      list = list.sort if list.all? { |item| item.kind_of?(Integer) && item >= 0 }
+      case list.size
+      when 1
+        block.call(list.first)
+      else
+        list[0...-1].collect { |d|
+          block.call(d)
+        }.join(", ") +
+          " #{connector} " + block.call(list.last)
+      end
+    end
+
+    # Format +date+ in a standard, human-readable format.
+    def humanize_date(date)
+      date.strftime("%B %d, %Y")
+    end
+
+    # Hash of cardinal integers to ordinal suffixes.
+    SUFFIX = {
+      1 => "st",
+      2 => "nd",
+      3 => "rd",
+      4 => "th",
+      5 => "th",
+      6 => "th",
+      7 => "th",
+      8 => "th",
+      9 => "th",
+      0 => "th",
+      11 => "th",
+      12 => "th",
+      13 => "th",
+    }
+
+    # Return the ordinal abbreviation for the integer +n+.  (e.g. 1 =>
+    # "1st", 3 => "3rd")
+    def ordinal(n)
+      if n == -1
+        "last"
+      elsif n == -2
+        "next to the last"
+      elsif n < 0
+        ordinal(-n) + " from the last"
+      else
+        n.to_s + suffix(n)
+      end        
+    end
+
+    # The ordinal suffex appropriate for the given number.  (e.g. 1 =>
+    # "st", 2 => "nd")
+    def suffix(n)
+      SUFFIX[n % 100] || SUFFIX[n % 10]
+    end
+
+    # Convenience method for accessing the class encoding token.
+    def encoding_token
+      self.class.encoding_token
+    end
+
+    # Build a params hash for this temporal expression.
+    def build_hash
+      builder = HashBuilder.new(encoding_token)
+      yield builder if block_given?
+      builder.hash
+    end
+
+    class << self
+      # The token to be used for encoding this temporal expression.
+      attr_reader :encoding_token
+      
+      # Register a parse callack for the encoding token for this
+      # class.  
+      def register_parse_callback(token, callback=self)
+        @encoding_token = token if callback == self
+        TExp.register_parse_callback(token, callback)
+      end
+  
+      # The default parsing callback for single argument time
+      # expressions.  Override if you need anything more complicated.
+      def parse_callback(stack)
+        stack.push new(stack.pop)
+      end
+    end
+  end
+end

data/lib/texp/core.rb

@@ -0,0 +1,41 @@
+module TExp
+  class << self
+    def from_db(string)
+      stack = []
+      string.split(":").each do |code|
+        case code
+        when /^\d+$/
+          stack.push(code.to_i)
+        when /^\d\d\d\d-\d\d-\d\d$/
+          stack.push(Date.parse(code))
+        when 'x'
+          n = stack.pop
+          args = []
+          n.times do args.unshift(stack.pop) end
+          stack.push args
+        when 'e'
+          stack.push TExp::EveryDay.new
+        when 'm'
+          stack.push TExp::DayOfMonth.new(stack.pop)
+        when 'w'
+          stack.push TExp::DayOfWeek.new(stack.pop)
+        when 'i'
+          interval = stack.pop
+          date = stack.pop
+          stack.push TExp::DayInterval.new(date, interval)
+        when 'a'
+          right = stack.pop
+          left = stack.pop
+          stack.push(TExp::And.new(left, right))
+        when 'o'
+          right = stack.pop
+          left = stack.pop
+          stack.push(TExp::Or.new(left, right))
+        else
+          fail "Unknown TExp DB Code"
+        end
+      end
+      stack.pop
+    end
+  end
+end

data/lib/texp/day_interval.rb

@@ -0,0 +1,55 @@
+module TExp
+  class DayInterval < Base
+    register_parse_callback('i')
+
+    def initialize(base_date, interval)
+      @base_date = base_date
+      @interval = interval
+    end
+
+    # Is +date+ included in the temporal expression.
+    def include?(date)
+      ((date.mjd - base_mjd) % @interval) == 0
+    end
+
+    # Human readable version of the temporal expression.
+    def inspect
+      if @interval == 1
+        "every day starting on #{humanize_date(@base_date)}"
+      else
+        "every #{ordinal(@interval)} day starting on #{humanize_date(@base_date)}"
+      end
+    end
+
+    # Encode the temporal expression into +codes+.
+    def encode(codes)
+      encode_date(codes, @base_date)
+      codes << ',' << @interval << encoding_token
+    end
+
+    def to_hash
+      build_hash do |b|
+        b.with(@base_date)
+        b.with(@interval)
+      end
+    end
+
+    private
+
+    def base_mjd
+      @base_date.mjd
+    end
+
+    def formatted_date
+      @base_date.strftime("%Y-%m-%d")
+    end
+
+    class << self
+      def parse_callback(stack)
+        interval = stack.pop
+        date = stack.pop
+        stack.push TExp::DayInterval.new(date, interval)
+      end
+    end
+  end
+end

data/lib/texp/day_of_month.rb

@@ -0,0 +1,32 @@
+module TExp
+  class DayOfMonth < Base
+    register_parse_callback('d')
+
+    def initialize(days)
+      @days = listize(days)
+    end
+
+    # Is +date+ included in the temporal expression.
+    def include?(date)
+      @days.include?(date.day)
+    end
+
+    # Human readable version of the temporal expression.
+    def inspect
+      "the day of the month is the " +
+        ordinal_list(@days)
+    end
+
+    # Encode the temporal expression into +codes+.
+    def encode(codes)
+      encode_list(codes, @days)
+      codes << encoding_token
+    end
+
+    def to_hash
+      build_hash do |b|
+        b.with(@days.map { |d| d.to_s })
+      end
+    end
+  end
+end

data/lib/texp/day_of_week.rb

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

data/lib/texp/every_day.rb

@@ -0,0 +1,30 @@
+module TExp
+  class EveryDay < Base
+    register_parse_callback('e')
+
+    # Is +date+ included in the temporal expression.
+    def include?(date)
+      true
+    end
+
+    # Human readable version of the temporal expression.
+    def inspect
+      "every day"
+    end
+
+    # Encode the temporal expression into +codes+.
+    def encode(codes)
+      codes << encoding_token
+    end
+
+    def to_hash
+      build_hash
+    end
+
+    class << self
+      def parse_callback(stack)
+        stack.push TExp::EveryDay.new
+      end
+    end
+  end
+end

data/lib/texp/ext.rb

@@ -0,0 +1,4 @@
+module TExp
+  module Extensions
+  end
+end

data/lib/texp/hash_builder.rb

@@ -0,0 +1,44 @@
+module TExp
+
+  # Build a temporal expression hash representation
+  #
+  # Usage:
+  #
+  #   builder = HashBuilder.new(encoding_token)
+  #   builder.with(the_first_paramter)
+  #   builder.with(the_next_parameter)
+  #   hash = builder.hash
+  #
+  class HashBuilder
+    # Convert the builder to a hash.
+    attr_reader :hash
+    
+    # Create a temporal expression params hash builder.
+    def initialize(type)
+      @type = type
+      @hash = { 'type' => type }
+      @args = 0
+    end
+    
+    # Add an argument to the hash.
+    def with(arg)
+      @args += 1
+      @hash["#{@type}#{@args}"] = simplify(arg)
+      self
+    end
+    
+    # Simplify the value to be placed in the hash.  Essentially we
+    # want only strings and lists.
+    def simplify(value)
+      case value
+      when String
+        value
+      when Array
+        value.map { |item| simplify(item) }
+      else
+        value.to_s
+      end
+    end
+  end
+
+end

data/lib/texp/logic.rb

@@ -0,0 +1,96 @@
+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
+    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) }
+    end
+
+    # Human readable version of the temporal expression.
+    def inspect
+      humanize_list(@terms, "and") { |item| item.inspect }
+    end
+
+    # Encode the temporal expression into +codes+.
+    def encode(codes)
+      encode_list(codes, @terms)
+      codes << encoding_token
+    end
+  end
+
+  # Logically OR a list of temporal expressions.  A date is included
+  # if it is included in any of the sub-expressions.
+  class Or < TermsBase
+    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) }
+    end
+
+    # Human readable version of the temporal expression.
+    def inspect
+      humanize_list(@terms) { |item| item.inspect }
+    end
+
+    # Encode the temporal expression into +codes+.
+    def encode(codes)
+      encode_list(codes, @terms)
+      codes << encoding_token
+    end
+  end
+
+  # Logically NEGATE a temporal expression.  A date is included if it
+  # is not included in the sub-expression.
+  class Not < Base
+    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)
+    end
+
+    # Human readable version of the temporal expression.
+    def inspect
+      "it is not the case that " + @term.inspect
+    end
+
+    # Encode the temporal expression into +codes+.
+    def encode(codes)
+      @term.encode(codes)
+      codes << encoding_token
+    end
+  end
+end