symphony 0.4.0 → 0.5.0

data/lib/symphony/mixins.rb

@@ -71,5 +71,151 @@ module Symphony
 	end # module MethodUtilities
 
 
+	# Functions for time calculations
+	module TimeFunctions
+
+		###############
+		module_function
+		###############
+
+		### Calculate the (approximate) number of seconds that are in +count+ of the
+		### given +unit+ of time.
+		def calculate_seconds( count, unit )
+			return case unit
+				when :seconds, :second
+					count
+				when :minutes, :minute
+					count * 60
+				when :hours, :hour
+					count * 3600
+				when :days, :day
+					count * 86400
+				when :weeks, :week
+					count * 604800
+				when :fortnights, :fortnight
+					count * 1209600
+				when :months, :month
+					count * 2592000
+				when :years, :year
+					count * 31557600
+				else
+					raise ArgumentError, "don't know how to calculate seconds in a %p" % [ unit ]
+				end
+		end
+
+	end # module TimeFunctions
+
+
+	# Refinements to Numeric to add time-related convenience methods
+	module TimeRefinements
+		refine Numeric do
+
+			### Number of seconds (returns receiver unmodified)
+			def seconds
+				return self
+			end
+			alias_method :second, :seconds
+
+			### Returns number of seconds in <receiver> minutes
+			def minutes
+				return TimeFunctions.calculate_seconds( self, :minutes )
+			end
+			alias_method :minute, :minutes
+
+			### Returns the number of seconds in <receiver> hours
+			def hours
+				return TimeFunctions.calculate_seconds( self, :hours )
+			end
+			alias_method :hour, :hours
+
+			### Returns the number of seconds in <receiver> days
+			def days
+				return TimeFunctions.calculate_seconds( self, :day )
+			end
+			alias_method :day, :days
+
+			### Return the number of seconds in <receiver> weeks
+			def weeks
+				return TimeFunctions.calculate_seconds( self, :weeks )
+			end
+			alias_method :week, :weeks
+
+			### Returns the number of seconds in <receiver> fortnights
+			def fortnights
+				return TimeFunctions.calculate_seconds( self, :fortnights )
+			end
+			alias_method :fortnight, :fortnights
+
+			### Returns the number of seconds in <receiver> months (approximate)
+			def months
+				return TimeFunctions.calculate_seconds( self, :months )
+			end
+			alias_method :month, :months
+
+			### Returns the number of seconds in <receiver> years (approximate)
+			def years
+				return TimeFunctions.calculate_seconds( self, :years )
+			end
+			alias_method :year, :years
+
+
+			### Returns the Time <receiver> number of seconds before the
+			### specified +time+. E.g., 2.hours.before( header.expiration )
+			def before( time )
+				return time - self
+			end
+
+
+			### Returns the Time <receiver> number of seconds ago. (e.g.,
+			### expiration > 2.hours.ago )
+			def ago
+				return self.before( ::Time.now )
+			end
+
+
+			### Returns the Time <receiver> number of seconds after the given +time+.
+			### E.g., 10.minutes.after( header.expiration )
+			def after( time )
+				return time + self
+			end
+
+
+			### Return a new Time <receiver> number of seconds from now.
+			def from_now
+				return self.after( ::Time.now )
+			end
+
+
+			### Return a string describing approximately the amount of time in
+			### <receiver> number of seconds.
+			def timeperiod
+				return case
+					when self < 1.minute
+						'less than a minute'
+					when self < 50.minutes
+						'%d minutes' % [ (self.to_f / 1.minute).ceil ]
+					when self < 90.minutes
+						'about an hour'
+					when self < 18.hours
+						"%d hours" % [ (self.to_f / 1.hour).ceil ]
+					when self < 30.hours
+						'about a day'
+					when self < 1.week
+						"%d days" % [ (self.to_f / 1.day).ceil ]
+					when self < 2.weeks
+						'about one week'
+					when self < 3.months
+						"%d weeks" % [ (self.to_f / 1.week).ceil ]
+					when self < 18.months
+						"%d months" % [ (self.to_f / 1.month).ceil ]
+					else
+						"%d years" % [ (self.to_f / 1.year).ceil ]
+					end
+			end
+
+		end # refine Numeric
+	end # module TimeRefinements
+
+end # module Symphony
+
 
-end # module Symphony

data/lib/symphony/task.rb

@@ -25,7 +25,7 @@ class Symphony::Task
 
 
 	# Signal to reset to defaults for the child
-	SIGNALS = %i[ INT TERM HUP CHLD WINCH ]
+	SIGNALS = %i[ INT TERM HUP ]
 
 	# Valid work model types
 	WORK_MODELS = %i[ longlived oneshot ]
@@ -319,10 +319,6 @@ class Symphony::Task
 			self.on_interrupt
 		when :HUP
 			self.on_hangup
-		when :CHLD
-			self.on_child_exit
-		when :WINCH
-			self.on_window_size_change
 		else
 			self.log.warn "Unhandled signal %s" % [ sig ]
 		end
@@ -379,19 +375,6 @@ class Symphony::Task
 	end
 
 
-	### Handle a child process exiting.
-	def on_child_exit
-		self.log.info "Child exited."
-		Process.waitpid( 0, Process::WNOHANG )
-	end
-
-
-	### Handle a window size change event. No-op by default.
-	def on_window_size_change
-		self.log.info "Window size changed."
-	end
-
-
 	### Handle a hangup signal by re-reading the config and restarting.
 	def on_hangup
 		self.log.info "Hangup signal."

data/spec/symphony/intervalexpression_spec.rb

@@ -0,0 +1,481 @@
+# vim: set nosta noet ts=4 sw=4 ft=rspec:
+
+require_relative '../helpers'
+require 'symphony/intervalexpression'
+require 'symphony/mixins'
+
+using Symphony::TimeRefinements
+
+
+#####################################################################
+###	C O N T E X T S
+#####################################################################
+
+describe Symphony::IntervalExpression do
+
+	let( :past ) { Time.at(1262376000) }
+
+	it "can't be instantiated directly" do
+		expect { described_class.new }.to raise_error( NoMethodError )
+	end
+
+	it "raises an exception if unable to parse the expression" do
+		expect {
+			described_class.parse( 'wut!' )
+		}.to raise_error( Symphony::TimeParseError, /unable to parse/ )
+	end
+
+	it "normalizes the expression before attempting to parse it" do
+		allow( Time ).to receive( :now ).and_return( past )
+		parsed = described_class.parse( '\'";At  2014---01-01   14::00(' )
+		expect( parsed.to_s ).to eq( 'at 2014-01-01 14:00' )
+	end
+
+	it "can parse the expression, offset from a different time" do
+		parsed = described_class.parse( 'every 5 seconds ending in an hour', past )
+		expect( parsed.starting ).to eq( past )
+		expect( parsed.ending ).to eq( past + 3600 )
+	end
+
+	it "is comparable" do
+		p1 = described_class.parse( 'at 2pm', past )
+		p2 = described_class.parse( 'at 3pm', past )
+		p3 = described_class.parse( 'at 2:00pm', past )
+
+		expect( p1 ).to be < p2
+		expect( p2 ).to be > p1
+		expect( p1 ).to eq( p3 )
+	end
+
+	it "won't allow scheduling dates in the past" do
+		expect {
+			described_class.parse( 'on 1999-01-01' )
+		}.to raise_error( Symphony::TimeParseError, /schedule in the past/ )
+	end
+
+	it "doesn't allow intervals of 0" do
+		expect {
+			described_class.parse( 'every 0 seconds' )
+		}.to raise_error( Symphony::TimeParseError, /unable to parse/ )
+	end
+
+
+	context 'exact times and dates' do
+
+		# stub for Time, tests are from this 'stuck' point:
+		# 2010-01-01 12:00
+		#
+		before( :each ) do
+			allow( Time ).to receive( :now ).and_return( past )
+		end
+
+		it 'at 2pm' do |example|
+			parsed = described_class.parse( example.description )
+			expect( parsed.valid ).to be
+			expect( parsed.recurring ).to be_falsey
+			expect( parsed.interval ).to be( 7200.0 )
+		end
+
+		it 'at 2:30pm' do |example|
+			parsed = described_class.parse( example.description )
+			expect( parsed.valid ).to be_truthy
+			expect( parsed.interval ).to be( 9000.0 )
+		end
+
+		it "pushes ambiguous times in today's past into tomorrow (at 11am)" do
+			parsed = described_class.parse( 'at 11am' )
+			expect( parsed.valid ).to be_truthy
+			expect( parsed.interval ).to be( 82800.0 )
+		end
+
+		it 'on 2010-01-02' do |example|
+			parsed = described_class.parse( example.description )
+			expect( parsed.valid ).to be_truthy
+			expect( parsed.interval ).to be( 43200.0 )
+		end
+
+		it 'on 2010-01-02 12:00' do |example|
+			parsed = described_class.parse( example.description )
+			expect( parsed.valid ).to be_truthy
+			expect( parsed.interval ).to be( 86400.0 )
+		end
+
+		it 'on 2010-01-02 12:00:01' do |example|
+			parsed = described_class.parse( example.description )
+			expect( parsed.valid ).to be_truthy
+			expect( parsed.interval ).to be( 86401.0 )
+		end
+
+		it 'correctly timeboxes the expression' do
+			parsed = described_class.parse( 'at 2pm' )
+			expect( parsed.valid ).to be_truthy
+			expect( parsed.interval ).to be( 7200.0 )
+			expect( parsed.ending ).to be_nil
+			expect( parsed.recurring ).to be_falsey
+			expect( parsed.starting ).to eq( past )
+		end
+
+		it 'always sets a start time if one is not specified' do
+			parsed = described_class.parse( 'at 2pm'  )
+			expect( parsed.valid ).to be_truthy
+			expect( parsed.recurring ).to be_falsey
+			expect( parsed.starting ).to eq( past )
+			expect( parsed.interval ).to be( 7200.0 )
+		end
+	end
+
+	context 'one-shot intervals' do
+
+		# stub for Time, tests are from this 'stuck' point:
+		# 2010-01-01 12:00
+		#
+		before( :each ) do
+			allow( Time ).to receive( :now ).and_return( past )
+		end
+
+		it 'in 30 seconds' do |example|
+			parsed = described_class.parse( example.description )
+			expect( parsed.valid ).to be_truthy
+			expect( parsed.recurring ).to be_falsey
+			expect( parsed.interval ).to be( 30.0 )
+		end
+
+		it 'in 30 seconds from now' do |example|
+			parsed = described_class.parse( example.description )
+			expect( parsed.valid ).to be_truthy
+			expect( parsed.interval ).to be( 30.0 )
+		end
+
+		it 'in an hour from now' do |example|
+			parsed = described_class.parse( example.description )
+			expect( parsed.valid ).to be_truthy
+			expect( parsed.interval ).to be( 3600.0 )
+		end
+
+		it 'in a minute' do |example|
+			parsed = described_class.parse( example.description )
+			expect( parsed.valid ).to be_truthy
+			expect( parsed.interval ).to be( 60.0 )
+		end
+
+		it 'correctly timeboxes the expression' do
+			parsed = described_class.parse( 'in 30 seconds' )
+			expect( parsed.valid ).to be_truthy
+			expect( parsed.interval ).to be( 30.0 )
+			expect( parsed.ending ).to be_nil
+			expect( parsed.recurring ).to be_falsey
+			expect( parsed.starting ).to eq( past )
+		end
+
+		it 'always sets a start time if one is not specified' do
+			parsed = described_class.parse( 'in 5 seconds'  )
+			expect( parsed.valid ).to be_truthy
+			expect( parsed.recurring ).to be_falsey
+			expect( parsed.starting ).to eq( past )
+			expect( parsed.interval ).to be( 5.0 )
+		end
+
+		it 'ignores end specifications for non-recurring run times' do
+			parsed = described_class.parse( 'run at 2010-01-02 end at 2010-03-01' )
+			expect( parsed.valid ).to be_truthy
+			expect( parsed.recurring ).to be_falsey
+			expect( parsed.starting ).to eq( past )
+			expect( parsed.ending ).to be_falsey
+			expect( parsed.interval ).to be( 43200.0 )
+		end
+	end
+
+	context 'repeating intervals' do
+
+		# stub for Time, tests are from this 'stuck' point:
+		# 2010-01-01 12:00
+		#
+		before( :each ) do
+			allow( Time ).to receive( :now ).and_return( past )
+		end
+
+		it 'every 500 milliseconds' do |example|
+			parsed = described_class.parse( example.description )
+			expect( parsed.valid ).to be_truthy
+			expect( parsed.recurring ).to be_truthy
+			expect( parsed.interval ).to be( 0.5 )
+		end
+
+		it 'every 30 seconds' do |example|
+			parsed = described_class.parse( example.description )
+			expect( parsed.valid ).to be_truthy
+			expect( parsed.recurring ).to be_truthy
+			expect( parsed.interval ).to be( 30.0 )
+		end
+
+		it 'once an hour' do |example|
+			parsed = described_class.parse( example.description )
+			expect( parsed.valid ).to be_truthy
+			expect( parsed.recurring ).to be_truthy
+			expect( parsed.interval ).to be( 3600.0 )
+		end
+
+		it 'once a minute' do |example|
+			parsed = described_class.parse( example.description )
+			expect( parsed.valid ).to be_truthy
+			expect( parsed.recurring ).to be_truthy
+			expect( parsed.interval ).to be( 60.0 )
+		end
+
+		it 'once per week' do |example|
+			parsed = described_class.parse( example.description )
+			expect( parsed.valid ).to be_truthy
+			expect( parsed.recurring ).to be_truthy
+			expect( parsed.interval ).to be( 604800.0 )
+		end
+
+		it 'every day' do |example|
+			parsed = described_class.parse( example.description )
+			expect( parsed.valid ).to be_truthy
+			expect( parsed.recurring ).to be_truthy
+			expect( parsed.interval ).to be( 86400.0 )
+		end
+
+		it 'every other day' do |example|
+			parsed = described_class.parse( example.description )
+			expect( parsed.valid ).to be_truthy
+			expect( parsed.recurring ).to be_truthy
+			expect( parsed.interval ).to be( 172800.0 )
+		end
+
+		it 'always sets a start time if one is not specified' do
+			parsed = described_class.parse( 'every 5 seconds'  )
+			expect( parsed.valid ).to be_truthy
+			expect( parsed.recurring ).to be_truthy
+			expect( parsed.starting ).to eq( past )
+			expect( parsed.interval ).to be( 5.0 )
+		end
+	end
+
+	context 'repeating intervals with only an expiration date' do
+
+		# stub for Time, tests are from this 'stuck' point:
+		# 2010-01-01 12:00
+		#
+		before( :each ) do
+			allow( Time ).to receive( :now ).and_return( past )
+		end
+
+		it 'every day ending in 1 week' do |example|
+			parsed = described_class.parse( example.description )
+			expect( parsed.valid ).to be_truthy
+			expect( parsed.recurring ).to be_truthy
+			expect( parsed.interval ).to be( 86400.0 )
+			expect( parsed.ending ).to eq( past + 604800 )
+		end
+
+		it 'once a day finishing in a week from now' do |example|
+			parsed = described_class.parse( example.description )
+			expect( parsed.valid ).to be_truthy
+			expect( parsed.recurring ).to be_truthy
+			expect( parsed.interval ).to be( 86400.0 )
+			expect( parsed.ending ).to eq( past + 604800 )
+		end
+
+		it 'once a day until 2010-02-01' do |example|
+			parsed = described_class.parse( example.description )
+			expect( parsed.valid ).to be_truthy
+			expect( parsed.recurring ).to be_truthy
+			expect( parsed.interval ).to be( 86400.0 )
+			expect( parsed.ending ).to eq( past + 2635200 )
+		end
+
+		it 'once a day end on 2010-02-01 00:00:10' do |example|
+			parsed = described_class.parse( example.description )
+			expect( parsed.valid ).to be_truthy
+			expect( parsed.recurring ).to be_truthy
+			expect( parsed.interval ).to be( 86400.0 )
+			expect( parsed.ending ).to eq( past + 2635210 )
+		end
+
+		it 'always sets a start time if one is not specified' do
+			parsed = described_class.parse( 'every 5 seconds ending in 1 week'  )
+			expect( parsed.valid ).to be_truthy
+			expect( parsed.recurring ).to be_truthy
+			expect( parsed.starting ).to eq( past )
+			expect( parsed.interval ).to be( 5.0 )
+			expect( parsed.ending ).to eq( past + 604800 )
+		end
+	end
+
+	context 'repeating intervals with only a start time' do
+
+		# stub for Time, tests are from this 'stuck' point:
+		# 2010-01-01 12:00
+		#
+		before( :each ) do
+			allow( Time ).to receive( :now ).and_return( past )
+		end
+
+		it "won't allow explicit start times with non-recurring run times" do
+			expect {
+				described_class.parse( 'start at 2010-02-01 run at 2010-02-01' )
+			}.to raise_error( Symphony::TimeParseError, /use 'at \[datetime\]' instead/ )
+		end
+
+		it 'starting in 5 minutes, run once a second' do |example|
+			parsed = described_class.parse( example.description )
+			expect( parsed.valid ).to be_truthy
+			expect( parsed.recurring ).to be_truthy
+			expect( parsed.starting ).to eq( past + 300 )
+			expect( parsed.interval ).to be( 1.0 )
+		end
+
+		it 'starting in a day execute every 3 minutes' do |example|
+			parsed = described_class.parse( example.description )
+			expect( parsed.valid ).to be_truthy
+			expect( parsed.recurring ).to be_truthy
+			expect( parsed.starting ).to eq( past + 86400 )
+			expect( parsed.interval ).to be( 180.0 )
+		end
+
+		it 'start at 2010-01-02 execute every 1 minute' do |example|
+			parsed = described_class.parse( example.description )
+			expect( parsed.valid ).to be_truthy
+			expect( parsed.recurring ).to be_truthy
+			expect( parsed.starting ).to eq( past + 43200 )
+			expect( parsed.interval ).to be( 60.0 )
+		end
+
+		it 'always sets a start time if one is not specified' do
+			parsed = described_class.parse( 'every 5 seconds'  )
+			expect( parsed.valid ).to be_truthy
+			expect( parsed.recurring ).to be_truthy
+			expect( parsed.starting ).to eq( past )
+			expect( parsed.interval ).to be( 5.0 )
+		end
+	end
+
+	context 'intervals with start and end times' do
+
+		# stub for Time, tests are from this 'stuck' point:
+		# 2010-01-01 12:00
+		#
+		before( :each ) do
+			allow( Time ).to receive( :now ).and_return( past )
+		end
+
+		it 'beginning in 1 hour from now run every 5 seconds ending on 2010-01-02' do |example|
+			parsed = described_class.parse( example.description )
+			expect( parsed.valid ).to be_truthy
+			expect( parsed.recurring ).to be_truthy
+			expect( parsed.starting ).to eq( past + 3600 )
+			expect( parsed.interval ).to be( 5.0 )
+			expect( parsed.ending ).to eq( past + 43200 )
+		end
+
+		it 'starting in 1 hour, run every 5 seconds and finish at 3pm' do |example|
+			parsed = described_class.parse( example.description )
+			expect( parsed.valid ).to be_truthy
+			expect( parsed.recurring ).to be_truthy
+			expect( parsed.starting ).to eq( past + 3600 )
+			expect( parsed.interval ).to be( 5.0 )
+			expect( parsed.ending ).to eq( past + 3600 * 3 )
+		end
+
+		it 'begin in an hour run every 5 seconds and then stop at 3pm' do |example|
+			parsed = described_class.parse( example.description )
+			expect( parsed.valid ).to be_truthy
+			expect( parsed.recurring ).to be_truthy
+			expect( parsed.starting ).to eq( past + 3600 )
+			expect( parsed.interval ).to be( 5.0 )
+			expect( parsed.ending ).to eq( past + 3600 * 3 )
+		end
+
+		it 'start at 2010-01-02 10:00 and then run each minute for the next 6 days' do |example|
+			parsed = described_class.parse( example.description )
+			expect( parsed.valid ).to be_truthy
+			expect( parsed.recurring ).to be_truthy
+			expect( parsed.starting ).to eq( past + 43200 + 36000 )
+			expect( parsed.interval ).to be( 60.0 )
+			expect( parsed.ending ).to eq( Time.parse('2010-01-02 10:00') + 86400 * 6 )
+		end
+	end
+
+	context 'intervals with a count' do
+
+		# stub for Time, tests are from this 'stuck' point:
+		# 2010-01-01 12:00
+		#
+		before( :each ) do
+			allow( Time ).to receive( :now ).and_return( past )
+		end
+
+		it "won't allow count multipliers without an interval nor an end date" do
+			expect {
+				described_class.parse( 'run 10 times' )
+			}.to raise_error( Symphony::TimeParseError, /end date or interval is required/ )
+		end
+
+		it '10 times a minute for 2 days' do |example|
+			parsed = described_class.parse( example.description )
+			expect( parsed.multiplier ).to be( 10 )
+			expect( parsed.recurring ).to be_truthy
+			expect( parsed.starting ).to eq( past )
+			expect( parsed.interval ).to be( 6.0 )
+			expect( parsed.ending ).to eq( past + 86400 * 2 )
+		end
+
+		it 'run 45 times every hour' do |example|
+			parsed = described_class.parse( example.description )
+			expect( parsed.multiplier ).to be( 45 )
+			expect( parsed.recurring ).to be_truthy
+			expect( parsed.starting ).to eq( past )
+			expect( parsed.interval ).to be( 80.0 )
+			expect( parsed.ending ).to be_nil
+		end
+
+		it 'start at 2010-01-02 run 12 times and end on 2010-01-03' do |example|
+			parsed = described_class.parse( example.description )
+			expect( parsed.multiplier ).to be( 12 )
+			expect( parsed.recurring ).to be_truthy
+			expect( parsed.starting ).to eq( past + 43200 )
+			expect( parsed.interval ).to be( 7200.0 )
+			expect( parsed.ending ).to eq( past + 86400 + 43200 )
+		end
+
+		it 'starting in an hour from now run 6 times a minute for 2 hours' do |example|
+			parsed = described_class.parse( example.description )
+			expect( parsed.multiplier ).to be( 6 )
+			expect( parsed.recurring ).to be_truthy
+			expect( parsed.starting ).to eq( past + 3600 )
+			expect( parsed.interval ).to be( 10.0 )
+			expect( parsed.ending ).to eq( past + 3600 * 3 )
+		end
+
+		it 'beginning a day from now, run 30 times per minute and finish in 2 weeks' do |example|
+			parsed = described_class.parse( example.description )
+			expect( parsed.multiplier ).to be( 30 )
+			expect( parsed.recurring ).to be_truthy
+			expect( parsed.starting ).to eq( past + 86400 )
+			expect( parsed.interval ).to be( 2.0 )
+			expect( parsed.ending ).to eq( past + 1209600 + 86400 )
+		end
+	end
+
+	context "when checking if it's okay to run" do
+
+		it 'returns true if the interval is within bounds' do
+			parsed = described_class.parse( 'at 2pm' )
+			expect( parsed.fire? ).to be_truthy
+		end
+
+		it 'returns nil if the ending (expiration) date has passed' do
+			allow( Time ).to receive( :now ).and_return( past )
+			parsed = described_class.parse( 'every minute' )
+			parsed.instance_variable_set( :@ending, past - 30 )
+			expect( parsed.fire? ).to be_nil
+		end
+
+		it 'returns false if the starting window has yet to occur' do
+			parsed = described_class.parse( 'starting in 2 hours run each minute' )
+			expect( parsed.fire? ).to be_falsey
+		end
+	end
+end
+