symphony 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d010875d95ecf17ce0545379d8192f0af823d93a
-  data.tar.gz: 94e08919b08b5a95e68ddc8989de48419e7c9275
+  metadata.gz: e56f49638e5786e9f84f0411f4065d2766582ea1
+  data.tar.gz: 2fd2aed4198733e2a6295a758eca506daa60f5db
 SHA512:
-  metadata.gz: 117430acaa264b8160de3df95869a34ffaf2dbe0e471269e333838ee52058fc4bd7932bcb99bccd38cbd00cd876c02addf413d15780a9d2fd132358321d1e966
-  data.tar.gz: ffed928bb686cd2aa65d82d696e1e487564e65d7b5f6b78a9a7a47ff71e303d5bb83a10257714333f4deca80d0381a246921610c9cca0758ff83482121ee5900
+  metadata.gz: 9d382c108292a680028806b3807a24475cee35d7d48b79eccba152eb27adb62136b68c0a99f5622668f44ffaf332048f4418a6140bf2d020525acf3f2df2f872
+  data.tar.gz: 90bee202f40bf9791f81775df6879adff6b2e07ed19101286f4eb3c47b2628306e80a5dd0678f0cb93b9662a3fef92d36159a0e4c2596707bb33c80bb81947c7

data/ChangeLog

@@ -1,9 +1,47 @@
+2014-04-04  Mahlon E. Smith  <mahlon@laika.com>
+
+	* .hgignore, Manifest.txt, Rakefile,
+	lib/symphony/intervalexpression.rl, lib/symphony/mixins.rb,
+	spec/symphony/intervalexpression_spec.rb,
+	spec/symphony/mixins_spec.rb:
+	Add an interval expression parsing library in preparation for
+	Symphony scheduling.
+	[cddc160bc76f] [tip]
+
+2014-04-01  Michael Granger  <ged@FaerieMUD.org>
+
+	* Rakefile:
+	Add direct dependency on loggability
+	[3afd6890a914] [github/master]
+
+	* TODO.md:
+	Update TODO list
+	[3615936701c5]
+
+	* lib/symphony/tasks/pinger.rb:
+	Remove the pinger example task
+	[cd84bece7998]
+
+2014-03-29  Michael Granger  <ged@FaerieMUD.org>
+
+	* .hgtags:
+	Added tag v0.4.0 for changeset ccf6adfeb268
+	[a5c661d2b122]
+
+	* .hgsigs:
+	Added signature for changeset 855c7801eaea
+	[ccf6adfeb268] [v0.4.0]
+
+	* History.rdoc, Rakefile, lib/symphony.rb:
+	Bump the minor version, update history.
+	[855c7801eaea]
+
 2014-03-28  Mahlon E. Smith  <mahlon@laika.com>
 
 	* lib/symphony/signal_handling.rb:
 	Just return true if a signal was handled in wait_for_signals(), or
 	false if a timeout occurred.
-	[aa8c912414a6] [tip]
+	[aa8c912414a6]
 
 	* lib/symphony/signal_handling.rb:
 	Add an optional (disabled by default) timeout for the signal
@@ -29,7 +67,7 @@
 	spec/symphony/daemon_spec.rb, spec/symphony/task_spec.rb,
 	spec/symphony_spec.rb:
 	Add some more Task specs, add a placeholder for Daemon specs.
-	[97812070cd5b] [github/master]
+	[97812070cd5b]
 
 	* TODO.md, USAGE.rdoc:
 	Update docs until we implement the generic plugin system

data/History.rdoc

@@ -1,3 +1,10 @@
+== v0.5.0 [2014-04-08] Michael Granger <ged@FaerieMUD.org>
+
+- Don't set up default signal handlers for WINCH and CHLD for Tasks.
+- Add an interval expression parsing library in preparation for
+  Symphony scheduling.
+
+
 == v0.4.0 [2014-03-28] Mahlon E. Smith <mahlon@martini.nu>
 
 Enhancement:

data/Manifest.txt

@@ -11,6 +11,7 @@ bin/symphony-task
 etc/config.yml.example
 lib/symphony.rb
 lib/symphony/daemon.rb
+lib/symphony/intervalexpression.rb
 lib/symphony/metrics.rb
 lib/symphony/mixins.rb
 lib/symphony/queue.rb
@@ -19,12 +20,12 @@ lib/symphony/signal_handling.rb
 lib/symphony/task.rb
 lib/symphony/tasks/auditor.rb
 lib/symphony/tasks/failure_logger.rb
-lib/symphony/tasks/pinger.rb
 lib/symphony/tasks/simulator.rb
 lib/symphony/tasks/ssh.rb
 lib/symphony/tasks/sshscript.rb
 spec/helpers.rb
 spec/symphony/daemon_spec.rb
+spec/symphony/intervalexpression_spec.rb
 spec/symphony/mixins_spec.rb
 spec/symphony/queue_spec.rb
 spec/symphony/task_spec.rb

data/Rakefile

@@ -1,12 +1,22 @@
 #!/usr/bin/env rake
 
+require 'pathname'
+
 begin
 	require 'hoe'
 rescue LoadError
 	abort "This Rakefile requires hoe (gem install hoe)"
 end
 
-GEMSPEC = 'symphony.gemspec'
+
+BASEDIR         = Pathname( __FILE__ ).dirname.relative_path_from( Pathname.pwd )
+
+LIBDIR          = BASEDIR + 'lib'
+SYMPHONY_LIBDIR = LIBDIR + 'symphony'
+
+GEMSPEC         = BASEDIR + 'symphony.gemspec'
+EXPRESSION_RL   = SYMPHONY_LIBDIR + 'intervalexpression.rl'
+EXPRESSION_RB   = SYMPHONY_LIBDIR + 'intervalexpression.rb'
 
 
 Hoe.plugin :mercurial
@@ -27,6 +37,7 @@ hoespec = Hoe.spec 'symphony' do |spec|
 	spec.developer 'Michael Granger', 'ged@FaerieMUD.org'
 	spec.developer 'Mahlon E. Smith', 'mahlon@martini.nu'
 
+	spec.dependency 'loggability', '~> 0.10'
 	spec.dependency 'pluggability', '~> 0.4'
 	spec.dependency 'bunny', '~> 1.1'
 	spec.dependency 'sysexits', '~> 1.1'
@@ -42,6 +53,8 @@ hoespec = Hoe.spec 'symphony' do |spec|
 
 	spec.require_ruby_version( '>=2.0.0' )
 	spec.hg_sign_tags = true if spec.respond_to?( :hg_sign_tags= )
+	spec.quality_check_whitelist.include( EXPRESSION_RB.to_s ) if
+		spec.respond_to?( :quality_check_whitelist )
 
 	self.rdoc_locations << "deveiate:/usr/local/www/public/code/#{remote_rdoc_dir}"
 end
@@ -51,10 +64,12 @@ ENV['VERSION'] ||= hoespec.spec.version.to_s
 # Run the tests before checking in
 task 'hg:precheckin' => [ :check_history, :check_manifest, :spec ]
 
+
 # Rebuild the ChangeLog immediately before release
 task :prerelease => 'ChangeLog'
 CLOBBER.include( 'ChangeLog' )
 
+
 desc "Build a coverage report"
 task :coverage do
 	ENV["COVERAGE"] = 'yes'
@@ -62,6 +77,16 @@ task :coverage do
 end
 
 
+# Generate the expression parser with Ragel
+file EXPRESSION_RL
+file EXPRESSION_RB
+task EXPRESSION_RB => EXPRESSION_RL do |task|
+	 sh 'ragel', '-R', '-T1', '-Ls', task.prerequisites.first
+end
+task :spec => EXPRESSION_RB
+
+
+# Generate a .gemspec file for integration with systems that read it
 task :gemspec => GEMSPEC
 file GEMSPEC => __FILE__ do |task|
 	spec = $hoespec.spec
@@ -71,6 +96,5 @@ file GEMSPEC => __FILE__ do |task|
 		fh.write( spec.to_ruby )
 	end
 end
-
 task :default => :gemspec
 

data/TODO.md

@@ -1,6 +1,4 @@
 
-[ ] Convert routing / metrics to 'plugins' syntax (inside/outside for prepend/include)
 [ ] Update pinger/ssh/sshscript
 [ ] Per Task throttling for daemon
 [ ] Task scaling (min/max settings), check queue backlog during received message
-[ ] Make the block of routes declared with on() method accept various arities

data/lib/symphony.rb

@@ -12,10 +12,10 @@ module Symphony
 	       Configurability
 
 	# Library version constant
-	VERSION = '0.4.0'
+	VERSION = '0.5.0'
 
 	# Version-control revision constant
-	REVISION = %q$Revision: 855c7801eaea $
+	REVISION = %q$Revision: 369353a62297 $
 
 
 	# The name of the environment variable to check for config file overrides

data/lib/symphony/intervalexpression.rb

@@ -0,0 +1,1216 @@
+
+# vim: set noet nosta sw=4 ts=4 ft=ragel :
+
+
+
+
+
+require 'symphony' unless defined?( Symphony )
+require 'symphony/mixins'
+require 'time'
+
+using Symphony::TimeRefinements
+
+
+### Parse natural English expressions of times and intervals.
+###
+###  in 30 minutes
+###  once an hour
+###  every 15 minutes for 2 days
+###  starting on 2014-05-01
+###  at 2014-04-01 14:00:25
+###  at 2pm
+###  starting at 2pm once a day
+###  start in 1 hour from now run every 5 seconds end at 11:15pm
+###  every other hour
+###  once a day ending in 1 week
+###  10 times a minute for 2 days
+###  run 45 times every hour
+###  start at 2010-01-02 run 12 times and end on 2010-01-03
+###  starting in an hour from now run 6 times a minute for 2 hours
+###  beginning a day from now, run 30 times per minute and finish in 2 weeks
+###
+class Symphony::IntervalExpression
+	include Comparable,
+	        Symphony::TimeFunctions
+	extend Loggability
+
+	log_to :symphony
+
+	# Ragel accessors are injected as class methods/variables for some reason.
+	
+class << self
+	attr_accessor :_interval_expression_key_offsets
+	private :_interval_expression_key_offsets, :_interval_expression_key_offsets=
+end
+self._interval_expression_key_offsets = [
+	0, 0, 10, 15, 19, 20, 21, 22, 
+	23, 40, 45, 54, 55, 56, 63, 64, 
+	65, 69, 84, 89, 94, 96, 97, 99, 
+	101, 102, 104, 106, 112, 114, 115, 117, 
+	119, 123, 124, 125, 126, 127, 128, 129, 
+	130, 132, 134, 136, 138, 140, 141, 149, 
+	158, 159, 160, 161, 162, 163, 165, 167, 
+	168, 169, 170, 171, 172, 173, 174, 175, 
+	176, 177, 178, 179, 180, 181, 182, 183, 
+	184, 185, 186, 194, 199, 205, 210, 215, 
+	218, 221, 226, 227, 230, 243, 247, 248, 
+	249, 250, 251, 253, 254, 255, 258, 261, 
+	262, 263, 264, 265, 266, 269, 285, 286, 
+	287, 288, 289, 290, 291, 292, 293, 294, 
+	295, 296, 297, 298, 305, 307, 308, 309, 
+	310, 311, 312, 313, 314, 315, 316, 317, 
+	319, 321, 322, 323, 324, 325, 326, 327, 
+	328, 329, 330, 331, 332, 333, 334, 335, 
+	336, 337, 338, 339, 340, 344, 347, 350, 
+	351, 352, 355, 368, 369, 370, 371, 372, 
+	373, 374, 375, 377, 378, 379, 382, 396, 
+	397, 398, 400, 401, 404, 409, 414, 419, 
+	421, 422, 424, 426, 427, 429, 431, 440, 
+	442, 443, 445, 447, 449, 451, 453, 455, 
+	457, 458, 459, 460, 461, 462, 467, 482, 
+	487, 492, 494, 495, 497, 499, 500, 502, 
+	504, 508, 520, 525, 531, 533, 535, 540, 
+	552, 555, 556, 557, 561, 571, 573, 574, 
+	575, 579, 580, 581, 584, 585, 586, 587, 
+	588, 589, 590, 591, 595, 606, 607, 608, 
+	611, 614, 618, 620, 622, 626, 628, 630, 
+	632, 633, 641, 650, 651, 652, 657, 661, 
+	662, 663, 664, 666, 668, 669, 670, 671, 
+	672, 673, 674, 675, 676, 677, 678, 679, 
+	680, 681, 682, 683, 684, 685, 686, 687, 
+	695, 700, 706, 711, 716, 719, 722, 727, 
+	728, 731, 744, 748, 749, 750, 751, 752, 
+	754, 755, 756, 759, 763, 764, 765, 766, 
+	767, 770, 774, 777, 781, 781, 784, 788, 
+	791, 794, 797, 800, 804
+]
+
+class << self
+	attr_accessor :_interval_expression_trans_keys
+	private :_interval_expression_trans_keys, :_interval_expression_trans_keys=
+end
+self._interval_expression_trans_keys = [
+	97, 98, 101, 105, 111, 112, 114, 115, 
+	48, 57, 32, 9, 13, 48, 57, 32, 
+	116, 9, 13, 105, 109, 101, 115, 32, 
+	97, 100, 101, 102, 104, 109, 111, 112, 
+	115, 117, 119, 121, 9, 13, 49, 57, 
+	32, 9, 13, 48, 57, 32, 100, 104, 
+	109, 115, 119, 121, 9, 13, 97, 121, 
+	32, 101, 102, 115, 117, 9, 13, 110, 
+	100, 32, 105, 9, 13, 32, 48, 97, 
+	100, 104, 105, 109, 111, 115, 119, 121, 
+	9, 13, 49, 57, 58, 97, 112, 48, 
+	57, 58, 97, 112, 48, 57, 48, 57, 
+	45, 48, 57, 48, 57, 45, 48, 57, 
+	48, 57, 32, 102, 9, 13, 48, 57, 
+	48, 57, 58, 48, 57, 48, 57, 32, 
+	102, 9, 13, 114, 111, 109, 32, 110, 
+	111, 119, 48, 57, 48, 57, 48, 57, 
+	48, 57, 97, 112, 109, 32, 58, 97, 
+	112, 9, 13, 48, 57, 32, 100, 104, 
+	109, 115, 119, 121, 9, 13, 97, 121, 
+	111, 117, 114, 105, 111, 108, 110, 108, 
+	105, 115, 101, 99, 111, 110, 100, 117, 
+	116, 101, 110, 116, 104, 101, 101, 107, 
+	101, 97, 32, 58, 97, 112, 9, 13, 
+	48, 57, 32, 9, 13, 48, 57, 32, 
+	45, 9, 13, 48, 57, 32, 9, 13, 
+	48, 57, 32, 110, 116, 9, 13, 32, 
+	9, 13, 32, 9, 13, 32, 9, 13, 
+	48, 57, 110, 32, 9, 13, 32, 97, 
+	100, 104, 109, 111, 115, 119, 121, 9, 
+	13, 49, 57, 32, 110, 9, 13, 116, 
+	104, 101, 114, 110, 116, 110, 103, 32, 
+	9, 13, 105, 111, 114, 110, 105, 115, 
+	104, 114, 32, 9, 13, 32, 48, 97, 
+	100, 104, 105, 109, 111, 115, 116, 119, 
+	121, 9, 13, 49, 57, 104, 101, 32, 
+	110, 101, 120, 116, 111, 109, 32, 110, 
+	111, 119, 32, 101, 102, 115, 117, 9, 
+	13, 105, 111, 116, 111, 112, 110, 116, 
+	105, 108, 111, 117, 114, 105, 111, 108, 
+	110, 108, 105, 115, 101, 99, 111, 110, 
+	100, 117, 116, 101, 110, 116, 104, 101, 
+	101, 107, 101, 97, 32, 110, 9, 13, 
+	32, 9, 13, 97, 110, 118, 99, 104, 
+	32, 9, 13, 32, 97, 100, 104, 109, 
+	111, 115, 119, 121, 9, 13, 49, 57, 
+	116, 104, 101, 114, 101, 114, 121, 110, 
+	116, 99, 101, 32, 9, 13, 32, 97, 
+	100, 104, 109, 111, 112, 115, 119, 121, 
+	9, 13, 49, 57, 101, 114, 101, 116, 
+	116, 32, 9, 13, 32, 9, 13, 48, 
+	57, 58, 97, 112, 48, 57, 58, 97, 
+	112, 48, 57, 48, 57, 45, 48, 57, 
+	48, 57, 45, 48, 57, 48, 57, 32, 
+	101, 102, 115, 117, 9, 13, 48, 57, 
+	48, 57, 58, 48, 57, 48, 57, 48, 
+	57, 48, 57, 48, 57, 48, 57, 97, 
+	112, 109, 101, 103, 105, 110, 32, 105, 
+	110, 9, 13, 32, 48, 97, 100, 104, 
+	105, 109, 111, 115, 119, 121, 9, 13, 
+	49, 57, 58, 97, 112, 48, 57, 58, 
+	97, 112, 48, 57, 48, 57, 45, 48, 
+	57, 48, 57, 45, 48, 57, 48, 57, 
+	32, 44, 9, 13, 32, 97, 101, 102, 
+	105, 111, 112, 114, 9, 13, 48, 57, 
+	32, 9, 13, 48, 57, 32, 58, 9, 
+	13, 48, 57, 48, 57, 48, 57, 32, 
+	44, 58, 9, 13, 32, 97, 101, 102, 
+	105, 111, 112, 114, 9, 13, 48, 57, 
+	97, 118, 120, 101, 99, 32, 117, 9, 
+	13, 32, 97, 101, 105, 111, 112, 9, 
+	13, 48, 57, 97, 118, 110, 110, 32, 
+	99, 9, 13, 116, 101, 32, 9, 13, 
+	114, 111, 109, 32, 110, 111, 119, 32, 
+	44, 9, 13, 32, 97, 101, 105, 111, 
+	112, 114, 9, 13, 48, 57, 117, 110, 
+	32, 9, 13, 32, 9, 13, 32, 102, 
+	9, 13, 48, 57, 48, 57, 32, 44, 
+	9, 13, 48, 57, 48, 57, 97, 112, 
+	109, 32, 58, 97, 112, 9, 13, 48, 
+	57, 32, 100, 104, 109, 115, 119, 121, 
+	9, 13, 97, 121, 32, 44, 115, 9, 
+	13, 32, 44, 9, 13, 111, 117, 114, 
+	105, 111, 108, 110, 108, 105, 115, 101, 
+	99, 111, 110, 100, 117, 116, 101, 110, 
+	116, 104, 101, 101, 107, 101, 97, 32, 
+	58, 97, 112, 9, 13, 48, 57, 32, 
+	9, 13, 48, 57, 32, 45, 9, 13, 
+	48, 57, 32, 9, 13, 48, 57, 32, 
+	110, 116, 9, 13, 32, 9, 13, 32, 
+	9, 13, 32, 9, 13, 48, 57, 110, 
+	32, 9, 13, 32, 97, 100, 104, 109, 
+	111, 115, 119, 121, 9, 13, 49, 57, 
+	32, 110, 9, 13, 116, 104, 101, 114, 
+	110, 116, 110, 103, 32, 9, 13, 32, 
+	105, 9, 13, 116, 97, 114, 116, 32, 
+	9, 13, 32, 115, 9, 13, 32, 9, 
+	13, 32, 58, 9, 13, 32, 9, 13, 
+	32, 115, 9, 13, 32, 9, 13, 32, 
+	9, 13, 32, 9, 13, 32, 9, 13, 
+	32, 58, 9, 13, 32, 9, 13, 0
+]
+
+class << self
+	attr_accessor :_interval_expression_single_lengths
+	private :_interval_expression_single_lengths, :_interval_expression_single_lengths=
+end
+self._interval_expression_single_lengths = [
+	0, 8, 1, 2, 1, 1, 1, 1, 
+	13, 1, 7, 1, 1, 5, 1, 1, 
+	2, 11, 3, 3, 0, 1, 0, 0, 
+	1, 0, 0, 2, 0, 1, 0, 0, 
+	2, 1, 1, 1, 1, 1, 1, 1, 
+	0, 0, 0, 0, 2, 1, 4, 7, 
+	1, 1, 1, 1, 1, 2, 2, 1, 
+	1, 1, 1, 1, 1, 1, 1, 1, 
+	1, 1, 1, 1, 1, 1, 1, 1, 
+	1, 1, 4, 1, 2, 1, 3, 1, 
+	1, 1, 1, 1, 9, 2, 1, 1, 
+	1, 1, 2, 1, 1, 1, 3, 1, 
+	1, 1, 1, 1, 1, 12, 1, 1, 
+	1, 1, 1, 1, 1, 1, 1, 1, 
+	1, 1, 1, 5, 2, 1, 1, 1, 
+	1, 1, 1, 1, 1, 1, 1, 2, 
+	2, 1, 1, 1, 1, 1, 1, 1, 
+	1, 1, 1, 1, 1, 1, 1, 1, 
+	1, 1, 1, 1, 2, 1, 3, 1, 
+	1, 1, 9, 1, 1, 1, 1, 1, 
+	1, 1, 2, 1, 1, 1, 10, 1, 
+	1, 2, 1, 1, 1, 3, 3, 0, 
+	1, 0, 0, 1, 0, 0, 5, 0, 
+	1, 0, 0, 0, 0, 0, 0, 2, 
+	1, 1, 1, 1, 1, 3, 11, 3, 
+	3, 0, 1, 0, 0, 1, 0, 0, 
+	2, 8, 1, 2, 0, 0, 3, 8, 
+	3, 1, 1, 2, 6, 2, 1, 1, 
+	2, 1, 1, 1, 1, 1, 1, 1, 
+	1, 1, 1, 2, 7, 1, 1, 1, 
+	1, 2, 0, 0, 2, 0, 0, 2, 
+	1, 4, 7, 1, 1, 3, 2, 1, 
+	1, 1, 2, 2, 1, 1, 1, 1, 
+	1, 1, 1, 1, 1, 1, 1, 1, 
+	1, 1, 1, 1, 1, 1, 1, 4, 
+	1, 2, 1, 3, 1, 1, 1, 1, 
+	1, 9, 2, 1, 1, 1, 1, 2, 
+	1, 1, 1, 2, 1, 1, 1, 1, 
+	1, 2, 1, 2, 0, 1, 2, 1, 
+	1, 1, 1, 2, 1
+]
+
+class << self
+	attr_accessor :_interval_expression_range_lengths
+	private :_interval_expression_range_lengths, :_interval_expression_range_lengths=
+end
+self._interval_expression_range_lengths = [
+	0, 1, 2, 1, 0, 0, 0, 0, 
+	2, 2, 1, 0, 0, 1, 0, 0, 
+	1, 2, 1, 1, 1, 0, 1, 1, 
+	0, 1, 1, 2, 1, 0, 1, 1, 
+	1, 0, 0, 0, 0, 0, 0, 0, 
+	1, 1, 1, 1, 0, 0, 2, 1, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 2, 2, 2, 2, 1, 1, 
+	1, 2, 0, 1, 2, 1, 0, 0, 
+	0, 0, 0, 0, 0, 1, 0, 0, 
+	0, 0, 0, 0, 1, 2, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 1, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 1, 1, 0, 0, 
+	0, 1, 2, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 1, 2, 0, 
+	0, 0, 0, 1, 2, 1, 1, 1, 
+	0, 1, 1, 0, 1, 1, 2, 1, 
+	0, 1, 1, 1, 1, 1, 1, 0, 
+	0, 0, 0, 0, 0, 1, 2, 1, 
+	1, 1, 0, 1, 1, 0, 1, 1, 
+	1, 2, 2, 2, 1, 1, 1, 2, 
+	0, 0, 0, 1, 2, 0, 0, 0, 
+	1, 0, 0, 1, 0, 0, 0, 0, 
+	0, 0, 0, 1, 2, 0, 0, 1, 
+	1, 1, 1, 1, 1, 1, 1, 0, 
+	0, 2, 1, 0, 0, 1, 1, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 2, 
+	2, 2, 2, 1, 1, 1, 2, 0, 
+	1, 2, 1, 0, 0, 0, 0, 0, 
+	0, 0, 1, 1, 0, 0, 0, 0, 
+	1, 1, 1, 1, 0, 1, 1, 1, 
+	1, 1, 1, 1, 1
+]
+
+class << self
+	attr_accessor :_interval_expression_index_offsets
+	private :_interval_expression_index_offsets, :_interval_expression_index_offsets=
+end
+self._interval_expression_index_offsets = [
+	0, 0, 10, 14, 18, 20, 22, 24, 
+	26, 42, 46, 55, 57, 59, 66, 68, 
+	70, 74, 88, 93, 98, 100, 102, 104, 
+	106, 108, 110, 112, 117, 119, 121, 123, 
+	125, 129, 131, 133, 135, 137, 139, 141, 
+	143, 145, 147, 149, 151, 154, 156, 163, 
+	172, 174, 176, 178, 180, 182, 185, 188, 
+	190, 192, 194, 196, 198, 200, 202, 204, 
+	206, 208, 210, 212, 214, 216, 218, 220, 
+	222, 224, 226, 233, 237, 242, 246, 251, 
+	254, 257, 261, 263, 266, 278, 282, 284, 
+	286, 288, 290, 293, 295, 297, 300, 304, 
+	306, 308, 310, 312, 314, 317, 332, 334, 
+	336, 338, 340, 342, 344, 346, 348, 350, 
+	352, 354, 356, 358, 365, 368, 370, 372, 
+	374, 376, 378, 380, 382, 384, 386, 388, 
+	391, 394, 396, 398, 400, 402, 404, 406, 
+	408, 410, 412, 414, 416, 418, 420, 422, 
+	424, 426, 428, 430, 432, 436, 439, 443, 
+	445, 447, 450, 462, 464, 466, 468, 470, 
+	472, 474, 476, 479, 481, 483, 486, 499, 
+	501, 503, 506, 508, 511, 515, 520, 525, 
+	527, 529, 531, 533, 535, 537, 539, 547, 
+	549, 551, 553, 555, 557, 559, 561, 563, 
+	566, 568, 570, 572, 574, 576, 581, 595, 
+	600, 605, 607, 609, 611, 613, 615, 617, 
+	619, 623, 634, 638, 643, 645, 647, 652, 
+	663, 667, 669, 671, 675, 684, 687, 689, 
+	691, 695, 697, 699, 702, 704, 706, 708, 
+	710, 712, 714, 716, 720, 730, 732, 734, 
+	737, 740, 744, 746, 748, 752, 754, 756, 
+	759, 761, 768, 777, 779, 781, 786, 790, 
+	792, 794, 796, 799, 802, 804, 806, 808, 
+	810, 812, 814, 816, 818, 820, 822, 824, 
+	826, 828, 830, 832, 834, 836, 838, 840, 
+	847, 851, 856, 860, 865, 868, 871, 875, 
+	877, 880, 892, 896, 898, 900, 902, 904, 
+	907, 909, 911, 914, 918, 920, 922, 924, 
+	926, 929, 933, 936, 940, 941, 944, 948, 
+	951, 954, 957, 960, 964
+]
+
+class << self
+	attr_accessor :_interval_expression_trans_targs
+	private :_interval_expression_trans_targs, :_interval_expression_trans_targs=
+end
+self._interval_expression_trans_targs = [
+	170, 193, 216, 222, 223, 167, 237, 300, 
+	2, 0, 3, 3, 2, 0, 3, 4, 
+	3, 0, 5, 0, 6, 0, 7, 0, 
+	304, 0, 8, 148, 11, 150, 94, 124, 
+	127, 162, 167, 169, 120, 143, 146, 8, 
+	9, 0, 10, 10, 9, 0, 10, 11, 
+	124, 127, 132, 143, 146, 10, 0, 12, 
+	0, 305, 0, 13, 14, 94, 117, 120, 
+	13, 0, 15, 0, 16, 0, 17, 91, 
+	17, 0, 17, 18, 78, 48, 50, 82, 
+	53, 90, 58, 69, 72, 17, 46, 0, 
+	42, 45, 45, 19, 0, 42, 45, 45, 
+	20, 0, 21, 0, 22, 0, 23, 0, 
+	24, 0, 25, 0, 26, 0, 306, 0, 
+	27, 33, 27, 28, 0, 29, 0, 30, 
+	0, 31, 0, 307, 0, 32, 33, 32, 
+	0, 34, 0, 35, 0, 36, 0, 37, 
+	0, 38, 0, 39, 0, 308, 0, 41, 
+	0, 309, 0, 43, 0, 44, 0, 45, 
+	45, 0, 309, 0, 47, 42, 45, 45, 
+	47, 74, 0, 47, 48, 50, 53, 58, 
+	69, 72, 47, 0, 49, 0, 310, 0, 
+	51, 0, 52, 0, 310, 0, 54, 66, 
+	0, 55, 63, 0, 56, 0, 57, 0, 
+	58, 0, 59, 0, 60, 0, 61, 0, 
+	62, 0, 310, 0, 64, 0, 65, 0, 
+	310, 0, 67, 0, 68, 0, 310, 0, 
+	70, 0, 71, 0, 310, 0, 73, 0, 
+	52, 0, 47, 42, 45, 45, 47, 75, 
+	0, 47, 47, 76, 0, 47, 22, 47, 
+	77, 0, 47, 47, 77, 0, 47, 79, 
+	80, 47, 0, 47, 47, 0, 81, 81, 
+	0, 81, 81, 18, 0, 83, 0, 84, 
+	84, 0, 84, 85, 48, 50, 53, 86, 
+	58, 69, 72, 84, 77, 0, 47, 79, 
+	47, 0, 87, 0, 88, 0, 89, 0, 
+	79, 0, 80, 87, 0, 92, 0, 93, 
+	0, 17, 17, 0, 95, 99, 109, 0, 
+	96, 0, 97, 0, 98, 0, 16, 0, 
+	100, 0, 101, 17, 0, 17, 18, 78, 
+	48, 50, 82, 53, 90, 58, 102, 69, 
+	72, 17, 46, 0, 103, 0, 104, 0, 
+	105, 0, 106, 0, 107, 0, 108, 0, 
+	93, 0, 110, 0, 111, 0, 112, 0, 
+	113, 0, 114, 0, 312, 0, 115, 14, 
+	116, 117, 120, 115, 0, 95, 99, 0, 
+	118, 0, 119, 0, 16, 0, 121, 0, 
+	122, 0, 123, 0, 93, 0, 125, 0, 
+	126, 0, 305, 0, 128, 140, 0, 129, 
+	137, 0, 130, 0, 131, 0, 132, 0, 
+	133, 0, 134, 0, 135, 0, 136, 0, 
+	305, 0, 138, 0, 139, 0, 305, 0, 
+	141, 0, 142, 0, 305, 0, 144, 0, 
+	145, 0, 305, 0, 147, 0, 126, 0, 
+	10, 149, 10, 0, 10, 10, 0, 151, 
+	15, 159, 0, 152, 0, 153, 0, 154, 
+	154, 0, 154, 148, 11, 124, 127, 155, 
+	132, 143, 146, 154, 9, 0, 156, 0, 
+	157, 0, 158, 0, 149, 0, 160, 0, 
+	161, 0, 153, 0, 163, 156, 0, 164, 
+	0, 165, 0, 166, 154, 0, 154, 148, 
+	11, 124, 127, 155, 167, 132, 143, 146, 
+	154, 9, 0, 168, 0, 153, 0, 133, 
+	118, 0, 171, 0, 172, 172, 0, 172, 
+	172, 173, 0, 189, 192, 192, 174, 0, 
+	189, 192, 192, 175, 0, 176, 0, 177, 
+	0, 178, 0, 179, 0, 180, 0, 181, 
+	0, 314, 0, 182, 14, 94, 117, 120, 
+	182, 183, 0, 184, 0, 185, 0, 186, 
+	0, 315, 0, 188, 0, 316, 0, 190, 
+	0, 191, 0, 192, 192, 0, 316, 0, 
+	194, 0, 195, 0, 196, 0, 197, 0, 
+	198, 296, 299, 198, 0, 198, 199, 283, 
+	251, 255, 287, 258, 295, 263, 274, 277, 
+	198, 249, 0, 245, 248, 248, 200, 0, 
+	245, 248, 248, 201, 0, 202, 0, 203, 
+	0, 204, 0, 205, 0, 206, 0, 207, 
+	0, 208, 0, 209, 240, 209, 0, 209, 
+	170, 216, 228, 222, 223, 167, 237, 209, 
+	210, 0, 3, 3, 211, 0, 3, 212, 
+	3, 2, 0, 213, 0, 214, 0, 215, 
+	240, 242, 215, 0, 215, 170, 216, 228, 
+	222, 223, 167, 237, 215, 2, 0, 151, 
+	159, 217, 0, 218, 0, 219, 0, 220, 
+	225, 220, 0, 220, 170, 221, 222, 223, 
+	167, 220, 2, 0, 151, 159, 0, 153, 
+	0, 224, 0, 172, 164, 172, 0, 226, 
+	0, 227, 0, 220, 220, 0, 229, 0, 
+	230, 0, 231, 0, 232, 0, 233, 0, 
+	234, 0, 235, 0, 236, 239, 236, 0, 
+	236, 170, 216, 222, 223, 167, 237, 236, 
+	2, 0, 238, 0, 227, 0, 236, 236, 
+	0, 241, 241, 0, 241, 228, 241, 0, 
+	243, 0, 244, 0, 215, 240, 215, 0, 
+	246, 0, 247, 0, 248, 248, 0, 244, 
+	0, 250, 245, 248, 248, 250, 279, 0, 
+	250, 251, 255, 258, 263, 274, 277, 250, 
+	0, 252, 0, 253, 0, 215, 240, 254, 
+	215, 0, 215, 240, 215, 0, 256, 0, 
+	257, 0, 253, 0, 259, 271, 0, 260, 
+	268, 0, 261, 0, 262, 0, 263, 0, 
+	264, 0, 265, 0, 266, 0, 267, 0, 
+	253, 0, 269, 0, 270, 0, 253, 0, 
+	272, 0, 273, 0, 253, 0, 275, 0, 
+	276, 0, 253, 0, 278, 0, 257, 0, 
+	250, 245, 248, 248, 250, 280, 0, 250, 
+	250, 281, 0, 250, 203, 250, 282, 0, 
+	250, 250, 282, 0, 250, 284, 285, 250, 
+	0, 250, 250, 0, 286, 286, 0, 286, 
+	286, 199, 0, 288, 0, 289, 289, 0, 
+	289, 290, 251, 255, 258, 291, 263, 274, 
+	277, 289, 282, 0, 250, 284, 250, 0, 
+	292, 0, 293, 0, 294, 0, 284, 0, 
+	285, 292, 0, 297, 0, 298, 0, 198, 
+	198, 0, 198, 296, 198, 0, 301, 0, 
+	302, 0, 303, 0, 299, 0, 8, 8, 
+	0, 13, 313, 13, 0, 27, 27, 0, 
+	32, 40, 32, 0, 0, 32, 32, 0, 
+	32, 311, 32, 0, 32, 32, 0, 115, 
+	115, 0, 13, 13, 0, 182, 182, 0, 
+	13, 187, 13, 0, 13, 13, 0, 0
+]
+
+class << self
+	attr_accessor :_interval_expression_trans_actions
+	private :_interval_expression_trans_actions, :_interval_expression_trans_actions=
+end
+self._interval_expression_trans_actions = [
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	1, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	2, 0, 0, 1, 1, 0, 0, 1, 
+	1, 1, 0, 1, 0, 1, 1, 0, 
+	1, 3, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 3, 0, 3, 0, 3, 0, 0, 
+	0, 3, 0, 1, 1, 1, 1, 0, 
+	1, 1, 1, 1, 1, 0, 1, 3, 
+	0, 0, 0, 0, 3, 0, 0, 0, 
+	0, 3, 0, 3, 0, 3, 0, 3, 
+	0, 3, 0, 3, 0, 3, 0, 3, 
+	0, 0, 0, 0, 3, 0, 3, 0, 
+	3, 0, 3, 0, 3, 0, 0, 0, 
+	3, 0, 3, 0, 3, 0, 3, 0, 
+	3, 0, 3, 0, 3, 0, 3, 0, 
+	3, 0, 3, 0, 3, 0, 3, 0, 
+	0, 3, 0, 3, 0, 0, 0, 0, 
+	0, 0, 3, 0, 0, 0, 0, 0, 
+	0, 0, 0, 3, 0, 3, 0, 3, 
+	0, 3, 0, 3, 0, 3, 0, 0, 
+	3, 0, 0, 3, 0, 3, 0, 3, 
+	0, 3, 0, 3, 0, 3, 0, 3, 
+	0, 3, 0, 3, 0, 3, 0, 3, 
+	0, 3, 0, 3, 0, 3, 0, 3, 
+	0, 3, 0, 3, 0, 3, 0, 3, 
+	0, 3, 0, 0, 0, 0, 0, 0, 
+	3, 0, 0, 0, 3, 0, 0, 0, 
+	0, 3, 0, 0, 0, 3, 0, 0, 
+	0, 0, 3, 0, 0, 3, 0, 0, 
+	3, 0, 0, 1, 3, 0, 3, 0, 
+	0, 3, 0, 1, 1, 1, 1, 1, 
+	1, 1, 1, 0, 1, 3, 0, 0, 
+	0, 3, 0, 3, 0, 3, 0, 3, 
+	0, 3, 0, 0, 3, 0, 3, 0, 
+	3, 0, 0, 3, 0, 0, 0, 3, 
+	0, 3, 0, 3, 0, 3, 0, 3, 
+	0, 3, 0, 0, 3, 0, 1, 1, 
+	1, 1, 0, 1, 1, 1, 0, 1, 
+	1, 0, 1, 3, 0, 3, 0, 3, 
+	0, 3, 0, 3, 0, 3, 0, 3, 
+	0, 3, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 3, 0, 0, 3, 
+	0, 3, 0, 3, 0, 3, 0, 3, 
+	0, 3, 0, 3, 0, 3, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 3, 0, 0, 2, 0, 0, 
+	0, 0, 0, 1, 1, 1, 1, 1, 
+	1, 1, 1, 0, 1, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 2, 0, 0, 0, 0, 0, 
+	0, 2, 0, 0, 0, 0, 0, 1, 
+	1, 1, 1, 1, 0, 1, 1, 1, 
+	0, 1, 0, 0, 0, 2, 0, 0, 
+	0, 3, 0, 0, 0, 0, 0, 0, 
+	0, 1, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 3, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 1, 1, 
+	1, 1, 0, 1, 1, 1, 1, 1, 
+	0, 1, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 4, 4, 4, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	1, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 4, 
+	4, 0, 4, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 1, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 1, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	1, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 4, 4, 4, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 5, 5, 0, 
+	5, 0, 5, 5, 5, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 1, 0, 0, 0, 0, 0, 0, 
+	0, 1, 1, 1, 1, 1, 1, 1, 
+	1, 0, 1, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 7, 7, 
+	0, 9, 0, 9, 0, 11, 11, 0, 
+	11, 0, 11, 0, 0, 11, 11, 0, 
+	14, 0, 14, 0, 14, 14, 0, 0, 
+	0, 0, 9, 9, 0, 16, 16, 0, 
+	16, 0, 16, 0, 16, 16, 0, 0
+]
+
+class << self
+	attr_accessor :_interval_expression_eof_actions
+	private :_interval_expression_eof_actions, :_interval_expression_eof_actions=
+end
+self._interval_expression_eof_actions = [
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	3, 0, 0, 0, 0, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 0, 0, 0, 
+	0, 0, 0, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 3, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 3, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 3, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	6, 8, 10, 10, 12, 10, 13, 13, 
+	12, 8, 15, 15, 15
+]
+
+class << self
+	attr_accessor :interval_expression_start
+end
+self.interval_expression_start = 1;
+class << self
+	attr_accessor :interval_expression_first_final
+end
+self.interval_expression_first_final = 304;
+class << self
+	attr_accessor :interval_expression_error
+end
+self.interval_expression_error = 0;
+
+class << self
+	attr_accessor :interval_expression_en_main
+end
+self.interval_expression_en_main = 1;
+
+
+
+	# The generic parse exception class.
+	class Symphony::TimeParseError < ArgumentError; end
+
+
+	########################################################################
+	### C L A S S   M E T H O D S
+	########################################################################
+
+	### Parse a schedule expression +exp+.
+	###
+	### Parsing defaults to Time.now(), but if passed a +time+ object,
+	### all contexual times (2pm) are relative to it.  If you know when
+	### an expression was generated, you can 'reconstitute' an interval
+	### object this way.
+	###
+	def self::parse( exp, time=nil )
+
+		# Normalize the expression before parsing
+		#
+		exp = exp.downcase.
+			gsub( /(?:[^[a-z][0-9][\-:]\s]+)/, '' ).  # : - a-z 0-9 only
+			gsub( /(?:and|then)/, '' ).               # remove common decorator words
+			gsub( /\s+/, ' ' ).                       # collapse whitespace
+			gsub( /([:\-])+/, '\1' )                  # collapse multiple - or : chars
+
+		event = new( exp, time || Time.now )
+		data  = event.instance_variable_get( :@data )
+
+		# Ragel interface variables
+		#
+		key    = ''
+		mark   = 0
+		
+begin
+	p ||= 0
+	pe ||= data.length
+	cs = interval_expression_start
+end
+
+		eof = pe
+		
+begin
+	testEof = false
+	_klen, _trans, _keys = nil
+	_goto_level = 0
+	_resume = 10
+	_eof_trans = 15
+	_again = 20
+	_test_eof = 30
+	_out = 40
+	while true
+	if _goto_level <= 0
+	if p == pe
+		_goto_level = _test_eof
+		next
+	end
+	if cs == 0
+		_goto_level = _out
+		next
+	end
+	end
+	if _goto_level <= _resume
+	_keys = _interval_expression_key_offsets[cs]
+	_trans = _interval_expression_index_offsets[cs]
+	_klen = _interval_expression_single_lengths[cs]
+	_break_match = false
+	
+	begin
+	  if _klen > 0
+	     _lower = _keys
+	     _upper = _keys + _klen - 1
+
+	     loop do
+	        break if _upper < _lower
+	        _mid = _lower + ( (_upper - _lower) >> 1 )
+
+	        if data[p].ord < _interval_expression_trans_keys[_mid]
+	           _upper = _mid - 1
+	        elsif data[p].ord > _interval_expression_trans_keys[_mid]
+	           _lower = _mid + 1
+	        else
+	           _trans += (_mid - _keys)
+	           _break_match = true
+	           break
+	        end
+	     end # loop
+	     break if _break_match
+	     _keys += _klen
+	     _trans += _klen
+	  end
+	  _klen = _interval_expression_range_lengths[cs]
+	  if _klen > 0
+	     _lower = _keys
+	     _upper = _keys + (_klen << 1) - 2
+	     loop do
+	        break if _upper < _lower
+	        _mid = _lower + (((_upper-_lower) >> 1) & ~1)
+	        if data[p].ord < _interval_expression_trans_keys[_mid]
+	          _upper = _mid - 2
+	        elsif data[p].ord > _interval_expression_trans_keys[_mid+1]
+	          _lower = _mid + 2
+	        else
+	          _trans += ((_mid - _keys) >> 1)
+	          _break_match = true
+	          break
+	        end
+	     end # loop
+	     break if _break_match
+	     _trans += _klen
+	  end
+	end while false
+	cs = _interval_expression_trans_targs[_trans];
+
+	if _interval_expression_trans_actions[_trans] != 0
+
+		case _interval_expression_trans_actions[_trans] 
+	when 1 then
+		begin
+ mark = p 		end
+	when 3 then
+		begin
+ event.instance_variable_set( :@valid, false ) 		end
+	when 2 then
+		begin
+ event.instance_variable_set( :@recurring, true ) 		end
+	when 4 then
+		begin
+
+		time = event.send( :extract, mark, p - mark )
+		event.send( :set_starting, time, :time )
+			end
+	when 5 then
+		begin
+
+		interval = event.send( :extract, mark, p - mark )
+		event.send( :set_starting, interval, :interval )
+			end
+	when 16 then
+		begin
+
+		time = event.send( :extract, mark, p - mark )
+		event.send( :set_interval, time, :time )
+			end
+	when 9 then
+		begin
+
+		interval = event.send( :extract, mark, p - mark )
+		event.send( :set_interval, interval, :interval )
+			end
+	when 7 then
+		begin
+
+		multiplier = event.send( :extract, mark, p - mark ).sub( / times/, '' )
+		event.instance_variable_set( :@multiplier, multiplier.to_i )
+			end
+	when 11 then
+		begin
+
+		time = event.send( :extract, mark, p - mark )
+		event.send( :set_ending, time, :time )
+			end
+	when 14 then
+		begin
+
+		interval = event.send( :extract, mark, p - mark )
+		event.send( :set_ending, interval, :interval )
+			end
+		end # action switch 
+	end
+
+	end
+	if _goto_level <= _again
+	if cs == 0
+		_goto_level = _out
+		next
+	end
+	p += 1
+	if p != pe
+		_goto_level = _resume
+		next
+	end
+	end
+	if _goto_level <= _test_eof
+	if p == eof
+	begin
+		case ( _interval_expression_eof_actions[cs] )
+	when 12 then
+		begin
+ event.instance_variable_set( :@valid, true ) 		end
+	when 3 then
+		begin
+ event.instance_variable_set( :@valid, false ) 		end
+	when 15 then
+		begin
+
+		time = event.send( :extract, mark, p - mark )
+		event.send( :set_interval, time, :time )
+			end
+		begin
+ event.instance_variable_set( :@valid, true ) 		end
+	when 8 then
+		begin
+
+		interval = event.send( :extract, mark, p - mark )
+		event.send( :set_interval, interval, :interval )
+			end
+		begin
+ event.instance_variable_set( :@valid, true ) 		end
+	when 6 then
+		begin
+
+		multiplier = event.send( :extract, mark, p - mark ).sub( / times/, '' )
+		event.instance_variable_set( :@multiplier, multiplier.to_i )
+			end
+		begin
+ event.instance_variable_set( :@valid, true ) 		end
+	when 10 then
+		begin
+
+		time = event.send( :extract, mark, p - mark )
+		event.send( :set_ending, time, :time )
+			end
+		begin
+ event.instance_variable_set( :@valid, true ) 		end
+	when 13 then
+		begin
+
+		interval = event.send( :extract, mark, p - mark )
+		event.send( :set_ending, interval, :interval )
+			end
+		begin
+ event.instance_variable_set( :@valid, true ) 		end
+		end
+	end
+	end
+
+	end
+	if _goto_level <= _out
+		break
+	end
+end
+	end
+
+
+		# Attach final time logic and sanity checks.
+		event.send( :finalize )
+
+		return event
+	end
+
+
+	########################################################################
+	### I N S T A N C E   M E T H O D S
+	########################################################################
+
+	### Instantiate a new TimeExpression, provided an +expression+ string
+	### that describes when this event will take place in natural english,
+	### and a +base+ Time to perform calculations against.
+	###
+	private_class_method :new
+	def initialize( expression, base ) # :nodoc:
+		@exp  = expression
+		@data = expression.to_s.unpack( 'c*' )
+		@base = base
+
+		@valid      = false
+		@recurring  = false
+		@starting   = nil
+		@interval   = nil
+		@multiplier = nil
+		@ending     = nil
+	end
+
+
+	######
+	public
+	######
+
+	# Is the schedule expression parsable?
+	attr_reader :valid
+
+	# Does this event repeat?
+	attr_reader :recurring
+
+	# The valid start time for the schedule (for recurring events)
+	attr_reader :starting
+
+	# The valid end time for the schedule (for recurring events)
+	attr_reader :ending
+
+	# The interval to wait before the event should be acted on.
+	attr_reader :interval
+
+	# An optional interval multipler for expressing counts.
+	attr_reader :multiplier
+
+
+	### If this interval is on a stack somewhere and ready to
+	### fire, is it okay to do so based on the specified
+	### expression criteria?
+	###
+	### Returns +true+ if it should fire, +false+ if it should not
+	### but could at a later attempt, and +nil+ if the interval has
+	### expired.
+	###
+	def fire?
+		now = Time.now
+
+		# Interval has expired.
+		return nil if self.ending && now > self.ending
+
+		# Interval is not yet in its current time window.
+		return false if self.starting - now > 0
+
+		# Looking good.
+		return true
+	end
+
+
+	### Just return the original event expression.
+	###
+	def to_s
+		return @exp
+	end
+
+
+	### Inspection string.
+	###
+	def inspect
+		return ( "<%s:0x%08x valid:%s recur:%s expression:%p " +
+					"starting:%p interval:%p ending:%p>" ) % [
+			self.class.name,
+			self.object_id * 2,
+			self.valid,
+			self.recurring,
+			self.to_s,
+			self.starting,
+			self.interval,
+			self.ending
+		]
+	end
+
+
+	### Comparable interface, order by interval, 'soonest' first.
+	###
+	def <=>( other )
+		return self.interval <=> other.interval
+	end
+
+
+	#########
+	protected
+	#########
+
+	### Given a +start+ and +ending+ scanner position,
+	### return an ascii representation of the data slice.
+	###
+	def extract( start, ending )
+		slice = @data[ start, ending ]
+		return '' unless slice
+		return slice.pack( 'c*' )
+	end
+
+
+	### Parse and set the starting attribute, given a +time_arg+
+	### string and the +type+ of string (interval or exact time)
+	###
+	def set_starting( time_arg, type )
+		start = self.get_time( time_arg, type )
+		@starting = start
+		return @starting
+	end
+
+
+	### Parse and set the interval attribute, given a +time_arg+
+	### string and the +type+ of string (interval or exact time)
+	###
+	### Perform consistency and sanity checks before returning an
+	### integer representing the amount of time needed to sleep before
+	### firing the event.
+	###
+	def set_interval( time_arg, type )
+		interval = nil
+		if self.starting && type == :time
+			raise Symphony::TimeParseError, "That doesn't make sense, just use 'at [datetime]' instead"
+		else
+			interval = self.get_time( time_arg, type )
+			interval = interval - @base
+		end
+
+		@interval = interval
+		return @interval
+	end
+
+
+	### Parse and set the ending attribute, given a +time_arg+
+	### string and the +type+ of string (interval or exact time)
+	###
+	### Perform consistency and sanity checks before returning a
+	### Time object.
+	###
+	def set_ending( time_arg, type )
+		ending = nil
+
+		# Ending dates only make sense for recurring events.
+		#
+		if self.recurring
+
+			# Make the interval an offset of the start time, instead of now.
+			#
+			# This is the contextual difference between:
+			#   every minute until 6 hours from now (ending based on NOW)
+			#   and
+			#   starting in a year run every minute for 1 month (ending based on start time)
+			#
+			if self.starting && type == :interval
+				diff = self.parse_interval( time_arg )
+				ending = self.starting + diff
+
+			# (offset from now)
+			#
+			else
+				ending = self.get_time( time_arg, type )
+			end
+
+			# Check the end time is after the start time.
+			#
+			if self.starting && ending < self.starting
+				raise Symphony::TimeParseError, "recurring event ends after it begins"
+			end
+
+		else
+			self.log.debug "Ignoring ending date, event is not recurring."
+		end
+
+		@ending = ending
+		return @ending
+	end
+
+
+	### Perform finishing logic and final sanity checks before returning
+	### a parsed object.
+	###
+	def finalize
+		raise Symphony::TimeParseError, "unable to parse expression" unless self.valid
+
+		# Ensure start time is populated.
+		#
+		# TODO: This will be required for future modulus
+		# (run every other day) feature.
+		#
+		@starting = @base unless self.starting
+
+		# Alter the interval if a multiplier was specified.
+		#
+		if self.multiplier
+			if self.ending
+
+				# Regular 'count' style multipler with end date.
+				# (run 10 times a minute for 2 days)
+				# Just divide the current interval by the count.
+				#
+				if self.interval
+					@interval = self.interval.to_f / self.multiplier
+
+				# Timeboxed multiplier (start [date] run 10 times end [date])
+				# Evenly spread the interval out over the time window.
+				#
+				else
+					diff = self.ending - self.starting
+					@interval = diff.to_f / self.multiplier
+				end
+
+			# Regular 'count' style multipler (run 10 times a minute)
+			# Just divide the current interval by the count.
+			#
+			else
+				raise Symphony::TimeParseError, "An end date or interval is required" unless self.interval
+				@interval = self.interval.to_f / self.multiplier
+			end
+		end
+	end
+
+
+	### Given a +time_arg+ string and a type (:interval or :time),
+	### dispatch to the appropriate parser.
+	###
+	def get_time( time_arg, type )
+		time = nil
+
+		if type == :interval
+			secs = self.parse_interval( time_arg )
+			time = @base + secs if secs
+		end
+
+		if type == :time
+			time = self.parse_time( time_arg )
+		end
+
+		raise Symphony::TimeParseError, "unable to parse time" if time.nil?
+		return time
+	end
+
+
+	### Parse a +time_arg+ string (anything parsable buy Time.parse())
+	### into a Time object.
+	###
+	def parse_time( time_arg )
+		time = Time.parse( time_arg, @base ) rescue nil
+
+		# Generated date is in the past.
+		#
+		if time && @base > time
+
+			# Ensure future dates for ambiguous times (2pm)
+			time = time + 1.day if time_arg.length < 8
+
+			# Still in the past, abandon all hope.
+			raise Symphony::TimeParseError, "attempt to schedule in the past" if @base > time
+		end
+
+		self.log.debug "Parsed %p (time) to: %p" % [ time_arg, time ]
+		return time
+	end
+
+
+	### Parse a +time_arg+ interval string ("30 seconds") into an
+	### Integer.
+	###
+	def parse_interval( interval_arg )
+		duration, span = interval_arg.split( /\s+/ )
+
+		# catch the 'a' or 'an' case (ex: "an hour")
+		duration = 1 if duration.index( 'a' ) == 0
+
+		# catch the 'other' case, ie: 'every other hour'
+		duration = 2 if duration == 'other'
+
+		# catch the singular case (ex: "hour")
+		unless span
+			span = duration
+			duration = 1
+		end
+
+		use_milliseconds = span.sub!( 'milli', '' )
+		interval = calculate_seconds( duration.to_i, span.to_sym )
+
+		# milliseconds
+		interval = duration.to_f / 1000 if use_milliseconds
+
+		self.log.debug "Parsed %p (interval) to: %p" % [ interval_arg, interval ]
+		return interval
+	end
+
+end # class TimeExpression
+