schedulability 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f82a8f51c6174d97745127776095269d18e02d80aa0230c196418c29de5a2d90
-  data.tar.gz: cbb1b0261b8ae97b7be7b89636ecb4afba4f67281f86401cadbf2ad092063d3c
+  metadata.gz: b1480aa1c07def4a986de461321563f3eb2bdf99de8fe70491e3c3c5cb724b41
+  data.tar.gz: 9a30eb358c982f4b94ee384a65a0b5e4b4296a9a35c832e5a4cdd66b1eced155
 SHA512:
-  metadata.gz: 28d07dd0b430a31ad3c209de07a6e3813852b1615b1f59cc862d1a74c6da041a178b472a596c0e81598c205ef1fd253342c2b099369e06f70eca7d768d67c29f
-  data.tar.gz: 6493a115a0c51cda15fc85a1d7d6ccfbcdb92af2cff13d7986134980dd9a37e0916907208d7892278dbfbfe867c91c489a6b6ce1fe422fd041bd15da210b8168
+  metadata.gz: f935aba6d33b855ff36f93d4d30766513c0d6234bd42aa547a8f92e8384eee0ac8ef5082fa6c8f08d36f3682bcb5b826092974673d50fdaa8e5b411a1166c28e
+  data.tar.gz: bc246c803a99603dbd4ecc34b3f66f72691dd0f49e98eef4365c70e81e065be777a7f7309f6b8f711edbe139df823cebe6dad3f29e97c3f7796656b57cc54c23

checksums.yaml.gz.sig

@@ -1,3 +1,3 @@
-��Գ$�LV����M��y=�֢�#k��p�G����C6�:v��L����ƅ`�=ke�h#D~�l�k*|���)e3X������=y��A��M���{Ro8�Or�[\W$�I�aC�̗tG��i�kW�kO��)��~@��A,&�5�1+Ƥb�n!�E�iYʔv�]�8 U켒�Ǽ�"|��)�+�O��<��:��<h��n>]����]�<��yc�O��'��@j
�����y
�q\�#.���.j0�L�@]���1e�@U�D>+�q���,������p�S����Ȫ�<m���+��Y���a����P��F��
-�Z椎
-�ZB�@cc�
m!-]�k�>��P�َ��x�'�٨a���^RHY
+��mj��v��kve��5j)������JK��2�
+�A|o\�o��Mn���^�kq<At��M֧^p���)�"[m���*�y�j��mk,�vf��u�&����uN��'fLz�Q	r�ju��>�x~���:��o�����hP��w=�e�K���M�i��ɠ�{L����~��Ǯ�\|Z���-�j��a�N�����i4�
+p�f�޼��e*����\��t�����%6/ު�{D�����S��w��Q��-��J�o Q�"�[s�N}�1)�%|��J���l�
	[��ܳ�s�{���x��}>x�Ir��bwh/E%�U��l�6���y���r��$�t�3W�.�.��}'uI����]PZ

data/ChangeLog

@@ -1,3 +1,79 @@
+2018-09-12  Michael Granger  <ged@FaerieMUD.org>
+
+	* lib/schedulability/schedule.rb:
+	Fix indentation warnings
+	[b576d8683cf1] [tip]
+
+	* .ruby-version:
+	Use Ruby 2.5 for development
+	[33f373ac276f]
+
+2018-08-31  Mahlon E. Smith  <mahlon@martini.nu>
+
+	* README.md:
+	Reflect reality in the README.
+	[cad3559428fe]
+
+2016-10-21  Michael Granger  <ged@FaerieMUD.org>
+
+	* .hgtags:
+	Added tag v0.3.0 for changeset cc6c1906a6a4
+	[62b3ca9f5313] [github/master]
+
+	* .hgsigs:
+	Added signature for changeset 4eb3e8287023
+	[cc6c1906a6a4] [v0.3.0]
+
+	* History.md, lib/schedulability.rb:
+	Bump the minor version and update history.
+	[4eb3e8287023]
+
+2016-07-29  Meining Lu  <meining@getupperhand.com>
+
+	* lib/schedulability/parser.rb, spec/schedulability/schedule_spec.rb:
+	[PATCH] Add support for 0th hour and 12am From
+	70ef3d9b003a736b26b4a57eae15393fa31516ef Mon Sep 17 00:00:00 2001
+	--- lib/schedulability/parser.rb | 12 +++++---
+	spec/schedulability/schedule_spec.rb | 57
+	+++++++++++++++++++++++++++++++++++- 2 files changed, 64
+	insertions(+), 5 deletions(-)
+
+	Closes ged/schedulability#2 (Github).
+	[67e0f911d188]
+
+2016-07-20  Michael Granger  <ged@FaerieMUD.org>
+
+	* .hgtags:
+	Added tag v0.2.0 for changeset 22dfe155d630
+	[fca786536ff4]
+
+	* .hgsigs:
+	Added signature for changeset 9332ac7ab656
+	[22dfe155d630] [v0.2.0]
+
+	* schedulability.gemspec:
+	Update gemspec
+	[9332ac7ab656]
+
+	* History.md, README.md, lib/schedulability.rb:
+	Update history, copyright, and bump minor version.
+	[bd7566ac26d5]
+
+	* lib/schedulability/schedule.rb:
+	Strip some more debug logging
+	[29c266cf0066]
+
+2016-07-17  Michael Granger  <ged@FaerieMUD.org>
+
+	* .gems, .ruby-gemset, .ruby-version, .rvmrc, Manifest.txt, Rakefile,
+	schedulability.gemspec:
+	Update manifest, switch to generic RVM setup.
+	[f1f0dfcccfa8]
+
+	* lib/schedulability/parser.rb:
+	Remove a bunch of spammy debug logs
+	[9bf76377c7b8]
+
 2016-07-14  Jason Rogers  <jacaetevha@gmail.com>
 
 	* lib/schedulability/parser.rb, spec/schedulability/schedule_spec.rb:
@@ -8,7 +84,7 @@
 	spec/schedulability/schedule_spec.rb | 52
 	++++++++++++++++++++++++++++++++++++ 2 files changed, 57
 	insertions(+), 3 deletions(-)
-	[0f59486cf040] [github/master, tip]
+	[0f59486cf040]
 
 2016-07-15  Michael Granger  <ged@FaerieMUD.org>
 

data/History.md

@@ -1,18 +1,30 @@
+## v0.4.0 [2018-09-12] Michael Granger <ged@FaerieMUD.org>
+
+Bugfixes:
+
+- Remove mixins only used in the specs.
+- Fix indentation warnings
+- Fix README examples
+
+
 ## v0.3.0 [2016-07-29] Michael Granger <ged@FaerieMUD.org>
 
 Bugfix:
-- Add support for 0th hour and 12am (thanks to 
+
+- Add support for 0th hour and 12am (thanks to
   Meining Lu <meining@getupperhand.com> on Github for the patch)
 
 
 ## v0.2.0 [2016-07-20] Michael Granger <ged@FaerieMUD.org>
 
 Bugfixes:
+
 - fixes for the 0th second or minute, and the 59th second
   (thanks to Jason Rogers <jacaetevha@gmail.com> for the patch)
 - Make Schedule#empty? take negative periods into account
 
 Enhancements
+
 - Add missing Schedule#overlaps? and #exclusive predicate methods.
 - Add a Schedule#to_s that stringifies them back into schedule descriptions
 

data/Manifest.txt

@@ -7,11 +7,9 @@ README.md
 Rakefile
 lib/schedulability.rb
 lib/schedulability/exceptions.rb
-lib/schedulability/mixins.rb
 lib/schedulability/parser.rb
 lib/schedulability/schedule.rb
 spec/helpers.rb
-spec/schedulability/mixins_spec.rb
 spec/schedulability/parser_spec.rb
 spec/schedulability/schedule_spec.rb
 spec/schedulability_spec.rb

data/README.md

@@ -158,10 +158,10 @@ Schedules are immutable after they're created, but they have mutator methods to
 allow you to compose the schedule you want by combining them, or by using
 mutator methods that return a changed copy of the original:
 
-    weekend = Schedulability::Schedule( "wd {Sat - Sun}" )
-    weekdays = Schedulability::Schedule( "wd {Mon - Fri}" )
-    work_hours = Schedulability::Schedule( "hour {9am - 5pm}" )
-    off_hours = Schedulability::Schedule( "hour {5pm - 9am}" )
+    weekend = Schedulability::Schedule.parse( "wd {Sat - Sun}" )
+    weekdays = Schedulability::Schedule.parse( "wd {Mon - Fri}" )
+    work_hours = Schedulability::Schedule.parse( "hour {9am - 5pm}" )
+    off_hours = Schedulability::Schedule.parse( "hour {5pm - 9am}" )
 
     ### Boolean operators
     on_duty = weekdays | work_hours
@@ -233,7 +233,7 @@ used under the terms of the Perl Artistic License.
 
 The rest is:
 
-Copyright (c) 2015-2016, Michael Granger and Mahlon E. Smith
+Copyright (c) 2015-2018, Michael Granger and Mahlon E. Smith
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

data/lib/schedulability.rb

@@ -10,10 +10,10 @@ module Schedulability
 	extend Loggability
 
 	# Package version constant
-	VERSION = '0.3.0'
+	VERSION = '0.4.0'
 
 	# VCS revision
-	REVISION = %q$Revision: 4eb3e8287023 $
+	REVISION = %q$Revision: fec56af1f0e4 $
 
 
 	# Loggability API -- set up a logger for Schedulability objects

data/lib/schedulability/schedule.rb

@@ -67,7 +67,7 @@ class Schedulability::Schedule
 
 		return ! self.negative_periods_include?( time_obj ) &&
 			self.positive_periods_include?( time_obj )
-	 end
+	end
 
 
 	 ### Returns +true+ if any of the schedule's positive periods include the
@@ -75,12 +75,12 @@ class Schedulability::Schedule
 	 def positive_periods_include?( time )
 		return self.positive_periods.empty? ||
 			find_matching_period_for( time, self.positive_periods )
-	 end
+	end
 
 
-	 ### Returns +true+ if any of the schedule's negative periods include the
-	 ### specified +time+.
-	 def negative_periods_include?( time )
+	### Returns +true+ if any of the schedule's negative periods include the
+	### specified +time+.
+	def negative_periods_include?( time )
 		return find_matching_period_for( time, self.negative_periods )
 	end
 

data/spec/schedulability/schedule_spec.rb

@@ -5,11 +5,8 @@ require_relative '../helpers'
 require 'time'
 require 'timecop'
 require 'schedulability/schedule'
-require 'schedulability/mixins'
 
 
-using Schedulability::TimeRefinements
-
 describe Schedulability::Schedule do
 
 	before( :all ) do
@@ -184,11 +181,11 @@ describe Schedulability::Schedule do
 			schedule = described_class.parse( "sec {18}" )
 			time = Time.iso8601( '2015-12-15T12:00:18-00:00' )
 
-			expect( schedule ).to_not include( time - 2.seconds )
-			expect( schedule ).to_not include( time - 1.second )
+			expect( schedule ).to_not include( time - 2 )
+			expect( schedule ).to_not include( time - 1 )
 			expect( schedule ).to include( time )
-			expect( schedule ).to_not include( time + 1.second )
-			expect( schedule ).to_not include( time + 2.seconds )
+			expect( schedule ).to_not include( time + 1 )
+			expect( schedule ).to_not include( time + 2 )
 		end
 
 
@@ -196,11 +193,11 @@ describe Schedulability::Schedule do
 			schedule = described_class.parse( "except sec {18}" )
 			time = Time.iso8601( '2015-12-15T12:00:18-00:00' )
 
-			expect( schedule ).to include( time - 2.seconds )
-			expect( schedule ).to include( time - 1.second )
+			expect( schedule ).to include( time - 2 )
+			expect( schedule ).to include( time - 1 )
 			expect( schedule ).to_not include( time )
-			expect( schedule ).to include( time + 1.second )
-			expect( schedule ).to include( time + 2.seconds )
+			expect( schedule ).to include( time + 1 )
+			expect( schedule ).to include( time + 2 )
 		end
 
 
@@ -208,12 +205,12 @@ describe Schedulability::Schedule do
 			schedule = described_class.parse( "sec {10-20}" )
 			time = Time.iso8601( '2015-12-15T12:00:10-00:00' )
 
-			expect( schedule ).to_not include( time - 2.seconds )
-			expect( schedule ).to_not include( time - 1.second )
+			expect( schedule ).to_not include( time - 2 )
+			expect( schedule ).to_not include( time - 1 )
 			expect( schedule ).to include( time )
-			expect( schedule ).to include( time + 1.second )
-			expect( schedule ).to include( time + 9.seconds )
-			expect( schedule ).to_not include( time + 10.seconds )
+			expect( schedule ).to include( time + 1 )
+			expect( schedule ).to include( time + 9 )
+			expect( schedule ).to_not include( time + 10 )
 		end
 
 
@@ -221,15 +218,15 @@ describe Schedulability::Schedule do
 			schedule = described_class.parse( "sec {45-15}" )
 			time = Time.iso8601( '2015-12-15T12:00:45-00:00' )
 
-			expect( schedule ).to_not include( time - 2.seconds )
-			expect( schedule ).to_not include( time - 1.second )
+			expect( schedule ).to_not include( time - 2 )
+			expect( schedule ).to_not include( time - 1 )
 			expect( schedule ).to include( time )
-			expect( schedule ).to include( time + 1.second )
-			expect( schedule ).to include( time + 14.seconds )
-			expect( schedule ).to include( time + 15.seconds )
-			expect( schedule ).to include( time + 20.seconds )
-			expect( schedule ).to include( time + 29.seconds )
-			expect( schedule ).to_not include( time + 30.seconds )
+			expect( schedule ).to include( time + 1 )
+			expect( schedule ).to include( time + 14 )
+			expect( schedule ).to include( time + 15 )
+			expect( schedule ).to include( time + 20 )
+			expect( schedule ).to include( time + 29 )
+			expect( schedule ).to_not include( time + 30 )
 		end
 
 
@@ -237,13 +234,13 @@ describe Schedulability::Schedule do
 			schedule = described_class.parse( "min {28}" )
 			time = Time.iso8601( '2015-12-15T12:28:00-00:00' )
 
-			expect( schedule ).to_not include( time - 15.seconds )
-			expect( schedule ).to_not include( time - 1.second )
+			expect( schedule ).to_not include( time - 15 )
+			expect( schedule ).to_not include( time - 1 )
 			expect( schedule ).to include( time )
-			expect( schedule ).to include( time + 38.seconds )
-			expect( schedule ).to include( time + 59.seconds )
-			expect( schedule ).to_not include( time + 1.minute )
-			expect( schedule ).to_not include( time + 2.minutes )
+			expect( schedule ).to include( time + 38 )
+			expect( schedule ).to include( time + 59 )
+			expect( schedule ).to_not include( time + 60 )
+			expect( schedule ).to_not include( time + 2 * 60 )
 		end
 
 
@@ -251,13 +248,13 @@ describe Schedulability::Schedule do
 			schedule = described_class.parse( "min {25-35}" )
 			time = Time.iso8601( '2015-12-15T12:25:00-00:00' )
 
-			expect( schedule ).to_not include( time - 2.minutes )
-			expect( schedule ).to_not include( time - 1.second )
+			expect( schedule ).to_not include( time - 60 )
+			expect( schedule ).to_not include( time - 1 )
 			expect( schedule ).to include( time )
-			expect( schedule ).to include( time + 1.minute )
-			expect( schedule ).to include( time + 9.minutes )
-			expect( schedule ).to include( time + 9.minutes + 59.seconds )
-			expect( schedule ).to_not include( time + 10.minutes )
+			expect( schedule ).to include( time + 60 )
+			expect( schedule ).to include( time + 9 * 60 )
+			expect( schedule ).to include( time + (9 * 60) + 59 )
+			expect( schedule ).to_not include( time + 10 * 60 )
 		end
 
 
@@ -265,18 +262,18 @@ describe Schedulability::Schedule do
 			schedule = described_class.parse( "min {50-15}" )
 			time = Time.iso8601( '2015-12-15T12:50:00-00:00' )
 
-			expect( schedule ).to_not include( time - 1.minute )
-			expect( schedule ).to_not include( time - 1.second )
+			expect( schedule ).to_not include( time - 60 )
+			expect( schedule ).to_not include( time - 1 )
 			expect( schedule ).to include( time )
-			expect( schedule ).to include( time + 1.second )
-			expect( schedule ).to include( time + 1.minute )
-			expect( schedule ).to include( time + 9.minutes )
-			expect( schedule ).to include( time + 9.minutes + 59.seconds )
-			expect( schedule ).to include( time + 10.minutes )
-			expect( schedule ).to include( time + 20.minutes )
-			expect( schedule ).to include( time + 24.minutes )
-			expect( schedule ).to include( time + 24.minutes + 59.seconds )
-			expect( schedule ).to_not include( time + 25.minutes )
+			expect( schedule ).to include( time + 1 )
+			expect( schedule ).to include( time + 60 )
+			expect( schedule ).to include( time + 9 * 60 )
+			expect( schedule ).to include( time + 9 * 60 + 59 )
+			expect( schedule ).to include( time + 10 * 60 )
+			expect( schedule ).to include( time + 20 * 60 )
+			expect( schedule ).to include( time + 24 * 60 )
+			expect( schedule ).to include( time + 24 * 60 + 59 )
+			expect( schedule ).to_not include( time + 25 * 60 )
 		end
 
 
@@ -286,11 +283,11 @@ describe Schedulability::Schedule do
 
 			expect( schedule ).to_not include( time - 1 )
 			expect( schedule ).to include( time )
-			expect( schedule ).to include( time + 1.minute )
-			expect( schedule ).to include( time + 20.minutes )
-			expect( schedule ).to include( time + (1.hour - 1.minute) )
-			expect( schedule ).to_not include( time + 1.hour )
-			expect( schedule ).to_not include( time + 3.hours )
+			expect( schedule ).to include( time + 60 )
+			expect( schedule ).to include( time + 20 * 60 )
+			expect( schedule ).to include( time + (3600 - 60) )
+			expect( schedule ).to_not include( time + 3600 )
+			expect( schedule ).to_not include( time + 3 * 3600 )
 		end
 
 
@@ -298,15 +295,15 @@ describe Schedulability::Schedule do
 			schedule = described_class.parse( "hr {9am-5pm}" )
 			time = Time.iso8601( '2015-12-15T09:00:00-00:00' )
 
-			expect( schedule ).to_not include( time - 12.hours )
-			expect( schedule ).to_not include( time - 10.minutes )
-			expect( schedule ).to_not include( time - 1.second )
+			expect( schedule ).to_not include( time - 12 * 3600 )
+			expect( schedule ).to_not include( time - 10 * 60 )
+			expect( schedule ).to_not include( time - 1 )
 			expect( schedule ).to include( time )
-			expect( schedule ).to include( time + 1.minute )
-			expect( schedule ).to include( time + 1.hour )
-			expect( schedule ).to include( time + 7.hours )
-			expect( schedule ).to include( time + (8.hours - 1.second) )
-			expect( schedule ).to_not include( time + 8.hours )
+			expect( schedule ).to include( time + 60 )
+			expect( schedule ).to include( time + 3600 )
+			expect( schedule ).to include( time + 7 * 3600 )
+			expect( schedule ).to include( time + (8 * 3600 - 1) )
+			expect( schedule ).to_not include( time + 8 * 3600 )
 		end
 
 
@@ -314,21 +311,21 @@ describe Schedulability::Schedule do
 			schedule = described_class.parse( "hr {5pm-9am}" )
 			time = Time.iso8601( '2015-12-15T17:00:00-00:00' )
 
-			expect( schedule ).to_not include( time - 1.hour )
-			expect( schedule ).to_not include( time - 1.second )
+			expect( schedule ).to_not include( time - 3600 )
+			expect( schedule ).to_not include( time - 1 )
 			expect( schedule ).to include( time )
-			expect( schedule ).to include( time + 1.second )
-			expect( schedule ).to include( time + 1.minute )
-			expect( schedule ).to include( time + 10.minutes )
-			expect( schedule ).to include( time + 2.hours )
-			expect( schedule ).to include( time + (7.hours - 1.second) )
-			expect( schedule ).to include( time + 7.hours )
-			expect( schedule ).to include( time + 12.hours )
-			expect( schedule ).to include( time + (16.hours - 1.second) )
-			expect( schedule ).to include( time + 24.hours )
-			expect( schedule ).to_not include( time + (24.hours - 1.second) )
-			expect( schedule ).to_not include( time + 16.hours )
-			expect( schedule ).to_not include( time + 18.hours )
+			expect( schedule ).to include( time + 1 )
+			expect( schedule ).to include( time + 60 )
+			expect( schedule ).to include( time + 10 * 60 )
+			expect( schedule ).to include( time + 2 * 3600 )
+			expect( schedule ).to include( time + (7 * 3600 - 1) )
+			expect( schedule ).to include( time + 7 * 3600 )
+			expect( schedule ).to include( time + 12 * 3600 )
+			expect( schedule ).to include( time + (16 * 3600 - 1) )
+			expect( schedule ).to include( time + 24 * 3600 )
+			expect( schedule ).to_not include( time + (24 * 3600 - 1) )
+			expect( schedule ).to_not include( time + 16 * 3600 )
+			expect( schedule ).to_not include( time + 18 * 3600 )
 		end
 
 
@@ -338,11 +335,11 @@ describe Schedulability::Schedule do
 
 			expect( schedule ).to_not include( time - 1 )
 			expect( schedule ).to include( time )
-			expect( schedule ).to include( time + 1.minute )
-			expect( schedule ).to include( time + 20.minutes )
-			expect( schedule ).to include( time + (1.hour - 1.minute) )
-			expect( schedule ).to_not include( time + 1.hour )
-			expect( schedule ).to_not include( time + 3.hours )
+			expect( schedule ).to include( time + 60 )
+			expect( schedule ).to include( time + 20 * 60 )
+			expect( schedule ).to include( time + (3600 - 60) )
+			expect( schedule ).to_not include( time + 3600 )
+			expect( schedule ).to_not include( time + 3 * 3600 )
 		end
 
 
@@ -353,11 +350,11 @@ describe Schedulability::Schedule do
 
 			expect( schedule ).to_not include( time - 1 )
 			expect( schedule ).to include( time )
-			expect( schedule ).to include( time + 1.minute )
-			expect( schedule ).to include( time + 20.minutes )
-			expect( schedule ).to include( time + (1.hour - 1.minute) )
-			expect( schedule ).to_not include( time + 1.hour )
-			expect( schedule ).to_not include( time + 3.hours )
+			expect( schedule ).to include( time + 60 )
+			expect( schedule ).to include( time + 20 * 60 )
+			expect( schedule ).to include( time + (3600 - 60) )
+			expect( schedule ).to_not include( time + 3600 )
+			expect( schedule ).to_not include( time + 3 * 3600 )
 		end
 
 
@@ -367,11 +364,11 @@ describe Schedulability::Schedule do
 
 			expect( schedule ).to_not include( time - 1 )
 			expect( schedule ).to include( time )
-			expect( schedule ).to include( time + 1.minute )
-			expect( schedule ).to include( time + 20.minutes )
-			expect( schedule ).to include( time + (1.hour - 1.minute) )
-			expect( schedule ).to_not include( time + 1.hour )
-			expect( schedule ).to_not include( time + 3.hours )
+			expect( schedule ).to include( time + 60 )
+			expect( schedule ).to include( time + 20 * 60 )
+			expect( schedule ).to include( time + (3600 - 60) )
+			expect( schedule ).to_not include( time + 3600 )
+			expect( schedule ).to_not include( time + 3 * 3600 )
 		end
 
 
@@ -381,11 +378,11 @@ describe Schedulability::Schedule do
 
 			expect( schedule ).to_not include( time - 1 )
 			expect( schedule ).to include( time )
-			expect( schedule ).to include( time + 1.minute )
-			expect( schedule ).to include( time + 20.minutes )
-			expect( schedule ).to include( time + (1.hour - 1.minute) )
-			expect( schedule ).to_not include( time + 1.hour )
-			expect( schedule ).to_not include( time + 3.hours )
+			expect( schedule ).to include( time + 60 )
+			expect( schedule ).to include( time + 20 * 60 )
+			expect( schedule ).to include( time + (3600 - 60) )
+			expect( schedule ).to_not include( time + 3600 )
+			expect( schedule ).to_not include( time + 3 * 3600 )
 		end
 
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: schedulability
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Michael Granger
@@ -11,9 +11,9 @@ bindir: bin
 cert_chain:
 - |
   -----BEGIN CERTIFICATE-----
-  MIIEbDCCAtSgAwIBAgIBATANBgkqhkiG9w0BAQsFADA+MQwwCgYDVQQDDANnZWQx
+  MIIEbDCCAtSgAwIBAgIBATANBgkqhkiG9w0BAQUFADA+MQwwCgYDVQQDDANnZWQx
   GTAXBgoJkiaJk/IsZAEZFglGYWVyaWVNVUQxEzARBgoJkiaJk/IsZAEZFgNvcmcw
-  HhcNMTYwODIwMTgxNzQyWhcNMTcwODIwMTgxNzQyWjA+MQwwCgYDVQQDDANnZWQx
+  HhcNMTcwOTI3MDAzMDQ0WhcNMTgwOTI3MDAzMDQ0WjA+MQwwCgYDVQQDDANnZWQx
   GTAXBgoJkiaJk/IsZAEZFglGYWVyaWVNVUQxEzARBgoJkiaJk/IsZAEZFgNvcmcw
   ggGiMA0GCSqGSIb3DQEBAQUAA4IBjwAwggGKAoIBgQC/JWGRHO+USzR97vXjkFgt
   83qeNf2KHkcvrRTSnR64i6um/ziin0I0oX23H7VYrDJC9A/uoUa5nGRJS5Zw/+wW
@@ -26,17 +26,17 @@ cert_chain:
   /D+K9JW9DDs3Yjgv9k4h7YMhW5gftosd+NkNC/+Y2CkCAwEAAaN1MHMwCQYDVR0T
   BAIwADALBgNVHQ8EBAMCBLAwHQYDVR0OBBYEFHKN/nkRusdqCJEuq3lgB3fJvyTg
   MBwGA1UdEQQVMBOBEWdlZEBGYWVyaWVNVUQub3JnMBwGA1UdEgQVMBOBEWdlZEBG
-  YWVyaWVNVUQub3JnMA0GCSqGSIb3DQEBCwUAA4IBgQAPJzKiT0zBU7kpqe0aS2qb
-  FI0PJ4y5I8buU4IZGUD5NEt/N7pZNfOyBxkrZkXhS44Fp+xwBH5ebLbq/WY78Bqd
-  db0z6ZgW4LMYMpWFfbXsRbd9TU2f52L8oMAhxOvF7Of5qJMVWuFQ8FPagk2iHrdH
-  inYLQagqAF6goWTXgAJCdPd6SNeeSNqA6vlY7CV1Jh5kfNJJ6xu/CVij1GzCLu/5
-  DMOr26DBv+qLJRRC/2h34uX71q5QgeOyxvMg+7V3u/Q06DXyQ2VgeeqiwDFFpEH0
-  PFkdPO6ZqbTRcLfNH7mFgCBJjsfSjJrn0sPBlYyOXgCoByfZnZyrIMH/UY+lgQqS
-  6Von1VDsfQm0eJh5zYZD64ZF86phSR7mUX3mXItwH04HrZwkWpvgd871DZVR3i1n
-  w8aNA5re5+Rt/Vvjxj5AcEnZnZiz5x959NaddQocX32Z1unHw44pzRNUur1GInfW
-  p4vpx2kUSFSAGjtCbDGTNV2AH8w9OU4xEmNz8c5lyoA=
+  YWVyaWVNVUQub3JnMA0GCSqGSIb3DQEBBQUAA4IBgQB/qyi5pCjK8ceoKalfVAjS
+  vG64FEnLnD1bm39T5UaFIRmo+abZtfpg2QhwKvPbPjOicau2+m+MDQ2Cc3tgyaC3
+  dZxcP6w8APFg4AId09uWAZKf0xajvBMS2aOz8Bbmag6fwqRRkTMqsNYnmqcF7aRT
+  DuEzbEMfaOUYjU9RuB48vr4q8yRft0ww+3jq5iwNkrX1buL2pwBbyvgms6D/BV41
+  MaTVMjsHqJUwU2xVfhGtxGAWAer5S1HGYHkbio6mGVtiie0uWjmnzi7ppIlMr48a
+  7BNTsoZ+/JRk3iQWmmNsyFT7xfqBKye7cH11BX8V8P4MeGB5YWlMI+Myj5DZY3fQ
+  st2AGD4rb1l0ia7PfubcBThSIdz61eCb8gRi/RiZZwb3/7+eyEncLJzt2Ob9fGSF
+  X0qdrKi+2aZZ0NGuFj9AItBsVmAvkBGIpX4TEKQp5haEbPpmaqO5nIIhV26PXmyT
+  OMKv6pWsoS81vw5KAGBmfX8nht/Py90DQrbRvakATGI=
   -----END CERTIFICATE-----
-date: 2016-10-21 00:00:00.000000000 Z
+date: 2018-09-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: loggability
@@ -72,14 +72,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: '0.9'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: '0.9'
 - !ruby/object:Gem::Dependency
   name: hoe-highline
   requirement: !ruby/object:Gem::Requirement
@@ -95,33 +95,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0.2'
 - !ruby/object:Gem::Dependency
-  name: rdoc
+  name: timecop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '0.8'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '0.8'
 - !ruby/object:Gem::Dependency
-  name: timecop
+  name: rdoc
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: '4.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: '4.2'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -142,14 +142,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.15'
+        version: '3.16'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.15'
+        version: '3.16'
 description: |-
   Schedulability is a library for describing scheduled time. You can specify one
   or more periods of time using a simple syntax, then combine them to describe
@@ -173,11 +173,9 @@ files:
 - Rakefile
 - lib/schedulability.rb
 - lib/schedulability/exceptions.rb
-- lib/schedulability/mixins.rb
 - lib/schedulability/parser.rb
 - lib/schedulability/schedule.rb
 - spec/helpers.rb
-- spec/schedulability/mixins_spec.rb
 - spec/schedulability/parser_spec.rb
 - spec/schedulability/schedule_spec.rb
 - spec/schedulability_spec.rb
@@ -203,7 +201,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: Schedulability is a library for describing scheduled time

metadata.gz.sig

@@ -1,2 +1,2 @@
-w��E�ٓ<��5���Z*�+��o�%�5��c���(�j�,�Ȼ�<�-g/���{�^1�/�,-L8���ҥC����Z��D�hg��sU���o2UU��(L�����Ab�f��T�V�<��C�g�m�8��d(<I��*B���sa�~��g��6�[&��T��,�-u_������V�c`��=�6ͨ�"�s,����~�)j����U7-�)�l;}ט�m�ш�a�,�+�3Z}C4�@�}���7P;����N�D0�aV_�"=�b��)�U�M�Ё�A4iV�$~� O3�T?����
-wڷ
��
�[�N��=-y�d��ə�}��|�Rr�X��D���_w@�>7="\C�
�bLƭ1L��_e���u�
+�`�>zuc���S�LA�)B���2B0�)�u�,��}�=Q&�A��'h�k5F8���}�@���I�`�Hu�[�p����J.��Z�]D%���XWԗicx)��fE�b
+X���c�����Ձc�E�j��U%Dx���?!)��<"m�

data/lib/schedulability/mixins.rb

@@ -1,201 +0,0 @@
-# -*- ruby -*-
-#encoding: utf-8
-
-require 'schedulability' unless defined?( Schedulability )
-
-module Schedulability
-
-	# 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
-
-		end # refine Numeric
-
-
-		refine Time do
-
-			# Approximate Time Constants (in seconds)
-			MINUTES = 60
-			HOURS   = 60  * MINUTES
-			DAYS    = 24  * HOURS
-			WEEKS   = 7   * DAYS
-			MONTHS  = 30  * DAYS
-			YEARS   = 365.25 * DAYS
-
-
-			### Returns +true+ if the receiver is a Time in the future.
-			def future?
-				return self > Time.now
-			end
-
-
-			### Returns +true+ if the receiver is a Time in the past.
-			def past?
-				return self < Time.now
-			end
-
-
-			### Return a description of the receiving Time object in relation to the current
-			### time.
-			###
-			### Example:
-			###
-			###    "Saved %s ago." % object.updated_at.as_delta
-			def as_delta
-				now = Time.now
-				if now > self
-					seconds = now - self
-					return "%s ago" % [ timeperiod(seconds) ]
-				else
-					seconds = self - now
-					return "%s from now" % [ timeperiod(seconds) ]
-				end
-			end
-
-
-			### Return a description of +seconds+ as the nearest whole unit of time.
-			def timeperiod( seconds )
-				return case
-					when seconds < MINUTES - 5
-						'less than a minute'
-					when seconds < 50 * MINUTES
-						if seconds <= 89
-							"a minute"
-						else
-							"%d minutes" % [ (seconds.to_f / MINUTES).ceil ]
-						end
-					when seconds < 90 * MINUTES
-						'about an hour'
-					when seconds < 18 * HOURS
-						"%d hours" % [ (seconds.to_f / HOURS).ceil ]
-					when seconds < 30 * HOURS
-						'about a day'
-					when seconds < WEEKS
-						"%d days" % [ (seconds.to_f / DAYS).ceil ]
-					when seconds < 2 * WEEKS
-						'about a week'
-					when seconds < 3 * MONTHS
-						"%d weeks" % [ (seconds.to_f / WEEKS).round ]
-					when seconds < 18 * MONTHS
-						"%d months" % [ (seconds.to_f / MONTHS).ceil ]
-					else
-						"%d years" % [ (seconds.to_f / YEARS).ceil ]
-					end
-			end
-
-		end # refine Time
-
-	end # module TimeRefinements
-
-end # module Schedulability
-

data/spec/schedulability/mixins_spec.rb

@@ -1,164 +0,0 @@
-#!/usr/bin/env rspec -cfd
-
-require_relative '../helpers'
-
-require 'schedulability/mixins'
-
-
-describe Schedulability, 'mixins' do
-
-
-	describe Schedulability::TimeRefinements do
-
-		using( described_class )
-
-
-		describe "used to extend Numeric objects" do
-
-			SECONDS_IN_A_MINUTE    = 60
-			SECONDS_IN_AN_HOUR     = SECONDS_IN_A_MINUTE * 60
-			SECONDS_IN_A_DAY       = SECONDS_IN_AN_HOUR * 24
-			SECONDS_IN_A_WEEK      = SECONDS_IN_A_DAY * 7
-			SECONDS_IN_A_FORTNIGHT = SECONDS_IN_A_WEEK * 2
-			SECONDS_IN_A_MONTH     = SECONDS_IN_A_DAY * 30
-			SECONDS_IN_A_YEAR      = Integer( SECONDS_IN_A_DAY * 365.25 )
-
-
-			it "can calculate the number of seconds for various units of time" do
-				expect( 1.second ).to eq( 1 )
-				expect( 14.seconds ).to eq( 14 )
-
-				expect( 1.minute ).to eq( SECONDS_IN_A_MINUTE )
-				expect( 18.minutes ).to eq( SECONDS_IN_A_MINUTE * 18 )
-
-				expect( 1.hour ).to eq( SECONDS_IN_AN_HOUR )
-				expect( 723.hours ).to eq( SECONDS_IN_AN_HOUR * 723 )
-
-				expect( 1.day ).to eq( SECONDS_IN_A_DAY )
-				expect( 3.days ).to eq( SECONDS_IN_A_DAY * 3 )
-
-				expect( 1.week ).to eq( SECONDS_IN_A_WEEK )
-				expect( 28.weeks ).to eq( SECONDS_IN_A_WEEK * 28 )
-
-				expect( 1.fortnight ).to eq( SECONDS_IN_A_FORTNIGHT )
-				expect( 31.fortnights ).to eq( SECONDS_IN_A_FORTNIGHT * 31 )
-
-				expect( 1.month ).to eq( SECONDS_IN_A_MONTH )
-				expect( 67.months ).to eq( SECONDS_IN_A_MONTH * 67 )
-
-				expect( 1.year ).to eq( SECONDS_IN_A_YEAR )
-				expect( 13.years ).to eq( SECONDS_IN_A_YEAR * 13 )
-			end
-
-
-			it "can calculate various time offsets" do
-				starttime = Time.now
-
-				expect( 1.second.after( starttime ) ).to eq( starttime + 1 )
-				expect( 18.seconds.from_now ).to be_within( 10.seconds ).of( starttime + 18 )
-
-				expect( 1.second.before( starttime ) ).to eq( starttime - 1 )
-				expect( 3.hours.ago ).to be_within( 10.seconds ).of( starttime - 10800 )
-			end
-
-		end
-
-
-		context "used to extend Time objects" do
-
-			it "makes them aware of whether they're in the future or not" do
-				Timecop.freeze do
-					time = Time.now
-					expect( time.future? ).to be_falsey
-
-					future_time = time + 1
-					expect( future_time.future? ).to be_truthy
-
-					past_time = time - 1
-					expect( past_time.future? ).to be_falsey
-				end
-			end
-
-
-			it "makes them aware of whether they're in the past or not" do
-				Timecop.freeze do
-					time = Time.now
-					expect( time.past? ).to be_falsey
-
-					future_time = time + 1
-					expect( future_time.past? ).to be_falsey
-
-					past_time = time - 1
-					expect( past_time.past? ).to be_truthy
-				end
-			end
-
-
-			it "adds the ability to express themselves as an offset in English" do
-				Timecop.freeze do
-					expect( 1.second.ago.as_delta ).to eq( 'less than a minute ago' )
-					expect( 1.second.from_now.as_delta ).to eq( 'less than a minute from now' )
-
-					expect( 1.minute.ago.as_delta ).to eq( 'a minute ago' )
-					expect( 1.minute.from_now.as_delta ).to eq( 'a minute from now' )
-					expect( 68.seconds.ago.as_delta ).to eq( 'a minute ago' )
-					expect( 68.seconds.from_now.as_delta ).to eq( 'a minute from now' )
-					expect( 2.minutes.ago.as_delta ).to eq( '2 minutes ago' )
-					expect( 2.minutes.from_now.as_delta ).to eq( '2 minutes from now' )
-					expect( 38.minutes.ago.as_delta ).to eq( '38 minutes ago' )
-					expect( 38.minutes.from_now.as_delta ).to eq( '38 minutes from now' )
-
-					expect( 1.hour.ago.as_delta ).to eq( 'about an hour ago' )
-					expect( 1.hour.from_now.as_delta ).to eq( 'about an hour from now' )
-					expect( 75.minutes.ago.as_delta ).to eq( 'about an hour ago' )
-					expect( 75.minutes.from_now.as_delta ).to eq( 'about an hour from now' )
-
-					expect( 2.hours.ago.as_delta ).to eq( '2 hours ago' )
-					expect( 2.hours.from_now.as_delta ).to eq( '2 hours from now' )
-					expect( 14.hours.ago.as_delta ).to eq( '14 hours ago' )
-					expect( 14.hours.from_now.as_delta ).to eq( '14 hours from now' )
-
-					expect( 22.hours.ago.as_delta ).to eq( 'about a day ago' )
-					expect( 22.hours.from_now.as_delta ).to eq( 'about a day from now' )
-					expect( 28.hours.ago.as_delta ).to eq( 'about a day ago' )
-					expect( 28.hours.from_now.as_delta ).to eq( 'about a day from now' )
-
-					expect( 36.hours.ago.as_delta ).to eq( '2 days ago' )
-					expect( 36.hours.from_now.as_delta ).to eq( '2 days from now' )
-					expect( 4.days.ago.as_delta ).to eq( '4 days ago' )
-					expect( 4.days.from_now.as_delta ).to eq( '4 days from now' )
-
-					expect( 1.week.ago.as_delta ).to eq( 'about a week ago' )
-					expect( 1.week.from_now.as_delta ).to eq( 'about a week from now' )
-					expect( 8.days.ago.as_delta ).to eq( 'about a week ago' )
-					expect( 8.days.from_now.as_delta ).to eq( 'about a week from now' )
-
-					expect( 15.days.ago.as_delta ).to eq( '2 weeks ago' )
-					expect( 15.days.from_now.as_delta ).to eq( '2 weeks from now' )
-					expect( 3.weeks.ago.as_delta ).to eq( '3 weeks ago' )
-					expect( 3.weeks.from_now.as_delta ).to eq( '3 weeks from now' )
-
-					expect( 1.month.ago.as_delta ).to eq( '4 weeks ago' )
-					expect( 1.month.from_now.as_delta ).to eq( '4 weeks from now' )
-					expect( 36.days.ago.as_delta ).to eq( '5 weeks ago' )
-					expect( 36.days.from_now.as_delta ).to eq( '5 weeks from now' )
-
-					expect( 6.months.ago.as_delta ).to eq( '6 months ago' )
-					expect( 6.months.from_now.as_delta ).to eq( '6 months from now' )
-					expect( 14.months.ago.as_delta ).to eq( '14 months ago' )
-					expect( 14.months.from_now.as_delta ).to eq( '14 months from now' )
-
-					expect( 6.year.ago.as_delta ).to eq( '6 years ago' )
-					expect( 6.year.from_now.as_delta ).to eq( '6 years from now' )
-					expect( 14.years.ago.as_delta ).to eq( '14 years ago' )
-					expect( 14.years.from_now.as_delta ).to eq( '14 years from now' )
-				end
-			end
-
-		end
-
-	end
-
-
-end
-