tod 1.5.0 → 2.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -2,24 +2,28 @@ require File.expand_path(File.join(File.dirname(__FILE__),'..','test_helper'))
2
2
  require File.expand_path(File.join(File.dirname(__FILE__),'..','support/active_record'))
3
3
 
4
4
  class Order < ActiveRecord::Base
5
- serialize :time, TimeOfDay
5
+ serialize :time, Tod::TimeOfDay
6
6
  end
7
- class TimeOfDayWithActiveRecordSerializableAttribute < Test::Unit::TestCase
8
- context "self.dump" do
9
- should "be able to set time of day" do
10
- Order.create(time: TimeOfDay.new(9, 30))
7
+
8
+ describe "TimeOfDay with ActiveRecord Serializable Attribute" do
9
+ describe ".dump" do
10
+ it "sets time of day" do
11
+ Order.create(time: Tod::TimeOfDay.new(9, 30))
11
12
  end
12
- should "be able to set nil as value" do
13
+
14
+ it "sets nil as value" do
13
15
  Order.create(time: nil)
14
16
  end
15
17
  end
16
- context "self.load" do
17
- should "load set time" do
18
- time_of_day = TimeOfDay.new(9, 30)
18
+
19
+ describe ".load" do
20
+ it "loads set time" do
21
+ time_of_day = Tod::TimeOfDay.new(9, 30)
19
22
  order = Order.create(time: time_of_day)
20
23
  assert_equal order.time, time_of_day
21
24
  end
22
- should "return nil if time is not set" do
25
+
26
+ it "returns nil if time is not set" do
23
27
  order = Order.create(time: nil)
24
28
  assert_equal order.time, nil
25
29
  end
@@ -1,58 +1,57 @@
1
1
  require File.expand_path(File.join(File.dirname(__FILE__),'..','test_helper'))
2
- require 'active_support/time'
3
2
 
4
- class TimeOfDayTest < Test::Unit::TestCase
5
- context "initialize" do
6
- should "block invalid hours" do
7
- assert_raise(ArgumentError) { TimeOfDay.new -1 }
8
- assert_raise(ArgumentError) { TimeOfDay.new 24 }
3
+ describe "TimeOfDay" do
4
+ describe "#initialize" do
5
+ it "blocks invalid hours" do
6
+ assert_raises(ArgumentError) { Tod::TimeOfDay.new -1 }
7
+ assert_raises(ArgumentError) { Tod::TimeOfDay.new 24 }
9
8
  end
10
9
 
11
- should "block invalid minutes" do
12
- assert_raise(ArgumentError) { TimeOfDay.new 0, -1 }
13
- assert_raise(ArgumentError) { TimeOfDay.new 0, 60 }
10
+ it "blocks invalid minutes" do
11
+ assert_raises(ArgumentError) { Tod::TimeOfDay.new 0, -1 }
12
+ assert_raises(ArgumentError) { Tod::TimeOfDay.new 0, 60 }
14
13
  end
15
14
 
16
- should "block invalid seconds" do
17
- assert_raise(ArgumentError) { TimeOfDay.new 0, 0, -1 }
18
- assert_raise(ArgumentError) { TimeOfDay.new 0, 0, 60 }
15
+ it "blocks invalid seconds" do
16
+ assert_raises(ArgumentError) { Tod::TimeOfDay.new 0, 0, -1 }
17
+ assert_raises(ArgumentError) { Tod::TimeOfDay.new 0, 0, 60 }
19
18
  end
20
19
  end
21
20
 
22
- context "second_of_day" do
23
- should "be 0 at midnight" do
24
- assert_equal 0, TimeOfDay.new(0,0,0).second_of_day
21
+ describe "second_of_day" do
22
+ it "is 0 at midnight" do
23
+ assert_equal 0, Tod::TimeOfDay.new(0,0,0).second_of_day
25
24
  end
26
25
 
27
- should "be 3661 at 1:01:01" do
28
- assert_equal 3661, TimeOfDay.new(1,1,1).second_of_day
26
+ it "is 3661 at 1:01:01" do
27
+ assert_equal 3661, Tod::TimeOfDay.new(1,1,1).second_of_day
29
28
  end
30
29
 
31
- should "be 86399 at last second of day" do
32
- assert_equal 86399, TimeOfDay.new(23,59,59).second_of_day
30
+ it "is 86399 at last second of day" do
31
+ assert_equal 86399, Tod::TimeOfDay.new(23,59,59).second_of_day
33
32
  end
34
33
 
35
- should "have alias to_i" do
36
- tod = TimeOfDay.new(0,0,0)
34
+ it "have alias to_i" do
35
+ tod = Tod::TimeOfDay.new(0,0,0)
37
36
  assert_equal tod.method(:second_of_day), tod.method(:to_i)
38
37
  end
39
38
  end
40
39
 
41
40
  def self.should_parse(parse_string, expected_hour, expected_minute, expected_second)
42
- expected_tod = TimeOfDay.new expected_hour, expected_minute, expected_second
41
+ expected_tod = Tod::TimeOfDay.new expected_hour, expected_minute, expected_second
43
42
 
44
- should "parse '#{parse_string}' into #{expected_tod.inspect}" do
45
- assert_equal true, TimeOfDay.parsable?(parse_string)
46
- assert_equal expected_tod, TimeOfDay.try_parse(parse_string)
47
- assert_equal expected_tod, TimeOfDay.parse(parse_string)
43
+ it "parses '#{parse_string}' into #{expected_tod.inspect}" do
44
+ assert_equal true, Tod::TimeOfDay.parsable?(parse_string)
45
+ assert_equal expected_tod, Tod::TimeOfDay.try_parse(parse_string)
46
+ assert_equal expected_tod, Tod::TimeOfDay.parse(parse_string)
48
47
  end
49
48
  end
50
49
 
51
50
  def self.should_not_parse(parse_string)
52
- should "not parse '#{parse_string}'" do
53
- assert_equal false, TimeOfDay.parsable?(parse_string)
54
- assert_equal nil, TimeOfDay.try_parse(parse_string)
55
- assert_raise(ArgumentError) { TimeOfDay.parse(parse_string) }
51
+ it "does not parse '#{parse_string}'" do
52
+ assert_equal false, Tod::TimeOfDay.parsable?(parse_string)
53
+ assert_equal nil, Tod::TimeOfDay.try_parse(parse_string)
54
+ assert_raises(ArgumentError) { Tod::TimeOfDay.parse(parse_string) }
56
55
  end
57
56
  end
58
57
 
@@ -97,123 +96,121 @@ class TimeOfDayTest < Test::Unit::TestCase
97
96
  should_not_parse ""
98
97
  should_not_parse []
99
98
 
100
- should "not parse 'nil'" do
101
- assert_equal false, TimeOfDay.parsable?(nil)
102
- assert_equal nil, TimeOfDay.try_parse(nil)
103
- assert_raise(ArgumentError) { TimeOfDay.parse(nil) }
99
+ it "does not parse 'nil'" do
100
+ assert_equal false, Tod::TimeOfDay.parsable?(nil)
101
+ assert_equal nil, Tod::TimeOfDay.try_parse(nil)
102
+ assert_raises(ArgumentError) { Tod::TimeOfDay.parse(nil) }
104
103
  end
105
104
 
106
- should "provide spaceship operator" do
107
- assert_equal -1, TimeOfDay.new(8,0,0) <=> TimeOfDay.new(9,0,0)
108
- assert_equal 0, TimeOfDay.new(9,0,0) <=> TimeOfDay.new(9,0,0)
109
- assert_equal 1, TimeOfDay.new(10,0,0) <=> TimeOfDay.new(9,0,0)
105
+ it "provides spaceship operator" do
106
+ assert_equal -1, Tod::TimeOfDay.new(8,0,0) <=> Tod::TimeOfDay.new(9,0,0)
107
+ assert_equal 0, Tod::TimeOfDay.new(9,0,0) <=> Tod::TimeOfDay.new(9,0,0)
108
+ assert_equal 1, Tod::TimeOfDay.new(10,0,0) <=> Tod::TimeOfDay.new(9,0,0)
110
109
  end
111
110
 
112
- should "compare equality by value" do
113
- assert_equal TimeOfDay.new(8,0,0), TimeOfDay.new(8,0,0)
111
+ it "compares equality by value" do
112
+ assert_equal Tod::TimeOfDay.new(8,0,0), Tod::TimeOfDay.new(8,0,0)
114
113
  end
115
114
 
116
115
 
117
- context "strftime" do
118
- should "delegate to Time.parse" do
119
- format_string = "%H:%M"
120
- Time.any_instance.expects(:strftime).with(format_string)
121
- TimeOfDay.new(8,15,30).strftime format_string
116
+ describe "strftime" do
117
+ it "accepts standard strftime format codes" do
118
+ assert_equal "08:15", Tod::TimeOfDay.new(8,15,30).strftime("%H:%M")
122
119
  end
123
120
  end
124
121
 
125
- context "to_s" do
126
- should "format to HH:MM:SS" do
127
- assert_equal "08:15:30", TimeOfDay.new(8,15,30).to_s
128
- assert_equal "22:10:45", TimeOfDay.new(22,10,45).to_s
122
+ describe "to_s" do
123
+ it "formats to HH:MM:SS" do
124
+ assert_equal "08:15:30", Tod::TimeOfDay.new(8,15,30).to_s
125
+ assert_equal "22:10:45", Tod::TimeOfDay.new(22,10,45).to_s
129
126
  end
130
127
  end
131
128
 
132
- context "to_i" do
133
- should "format to integer" do
134
- assert_equal 29730, TimeOfDay.new(8,15,30).to_i
135
- assert TimeOfDay.new(22,10,45).to_i.is_a? Integer
129
+ describe "to_i" do
130
+ it "formats to integer" do
131
+ assert_equal 29730, Tod::TimeOfDay.new(8,15,30).to_i
132
+ assert Tod::TimeOfDay.new(22,10,45).to_i.is_a? Integer
136
133
  end
137
134
  end
138
135
 
139
- context "addition" do
140
- should "add seconds" do
141
- original = TimeOfDay.new(8,0,0)
136
+ describe "addition" do
137
+ it "adds seconds" do
138
+ original = Tod::TimeOfDay.new(8,0,0)
142
139
  result = original + 15
143
- assert_equal TimeOfDay.new(8,0,15), result
140
+ assert_equal Tod::TimeOfDay.new(8,0,15), result
144
141
  end
145
142
 
146
- should "wrap around midnight" do
147
- original = TimeOfDay.new(23,0,0)
143
+ it "wraps around midnight" do
144
+ original = Tod::TimeOfDay.new(23,0,0)
148
145
  result = original + 7200
149
- assert_equal TimeOfDay.new(1,0,0), result
146
+ assert_equal Tod::TimeOfDay.new(1,0,0), result
150
147
  end
151
148
 
152
- should "return new TimeOfDay" do
153
- original = TimeOfDay.new(8,0,0)
149
+ it "returns new Tod::TimeOfDay" do
150
+ original = Tod::TimeOfDay.new(8,0,0)
154
151
  result = original + 15
155
- assert_not_equal original.object_id, result.object_id
152
+ refute_equal original.object_id, result.object_id
156
153
  end
157
154
  end
158
155
 
159
- context "subtraction" do
160
- should "subtract seconds" do
161
- original = TimeOfDay.new(8,0,0)
156
+ describe "subtraction" do
157
+ it "subtracts seconds" do
158
+ original = Tod::TimeOfDay.new(8,0,0)
162
159
  result = original - 15
163
- assert_equal TimeOfDay.new(7,59,45), result
160
+ assert_equal Tod::TimeOfDay.new(7,59,45), result
164
161
  end
165
162
 
166
- should "wrap around midnight" do
167
- original = TimeOfDay.new(1,0,0)
163
+ it "wraps around midnight" do
164
+ original = Tod::TimeOfDay.new(1,0,0)
168
165
  result = original - 7200
169
- assert_equal TimeOfDay.new(23,0,0), result
166
+ assert_equal Tod::TimeOfDay.new(23,0,0), result
170
167
  end
171
168
 
172
- should "return new TimeOfDay" do
173
- original = TimeOfDay.new(8,0,0)
169
+ it "returns new Tod::TimeOfDay" do
170
+ original = Tod::TimeOfDay.new(8,0,0)
174
171
  result = original - 15
175
- assert_not_equal original.object_id, result.object_id
172
+ refute_equal original.object_id, result.object_id
176
173
  end
177
174
  end
178
175
 
179
- context "from_second_of_day" do
180
- should "handle positive numbers" do
181
- assert_equal TimeOfDay.new(0,0,30), TimeOfDay.from_second_of_day(30)
182
- assert_equal TimeOfDay.new(0,1,30), TimeOfDay.from_second_of_day(90)
183
- assert_equal TimeOfDay.new(1,1,5), TimeOfDay.from_second_of_day(3665)
184
- assert_equal TimeOfDay.new(23,59,59), TimeOfDay.from_second_of_day(86399)
176
+ describe "from_second_of_day" do
177
+ it "handles positive numbers" do
178
+ assert_equal Tod::TimeOfDay.new(0,0,30), Tod::TimeOfDay.from_second_of_day(30)
179
+ assert_equal Tod::TimeOfDay.new(0,1,30), Tod::TimeOfDay.from_second_of_day(90)
180
+ assert_equal Tod::TimeOfDay.new(1,1,5), Tod::TimeOfDay.from_second_of_day(3665)
181
+ assert_equal Tod::TimeOfDay.new(23,59,59), Tod::TimeOfDay.from_second_of_day(86399)
185
182
  end
186
183
 
187
- should "handle positive numbers a day or more away" do
188
- assert_equal TimeOfDay.new(0,0,0), TimeOfDay.from_second_of_day(86400)
189
- assert_equal TimeOfDay.new(0,0,30), TimeOfDay.from_second_of_day(86430)
190
- assert_equal TimeOfDay.new(0,1,30), TimeOfDay.from_second_of_day(86490)
191
- assert_equal TimeOfDay.new(1,1,5), TimeOfDay.from_second_of_day(90065)
192
- assert_equal TimeOfDay.new(23,59,59), TimeOfDay.from_second_of_day(172799)
184
+ it "handles positive numbers a day or more away" do
185
+ assert_equal Tod::TimeOfDay.new(0,0,0), Tod::TimeOfDay.from_second_of_day(86400)
186
+ assert_equal Tod::TimeOfDay.new(0,0,30), Tod::TimeOfDay.from_second_of_day(86430)
187
+ assert_equal Tod::TimeOfDay.new(0,1,30), Tod::TimeOfDay.from_second_of_day(86490)
188
+ assert_equal Tod::TimeOfDay.new(1,1,5), Tod::TimeOfDay.from_second_of_day(90065)
189
+ assert_equal Tod::TimeOfDay.new(23,59,59), Tod::TimeOfDay.from_second_of_day(172799)
193
190
  end
194
191
 
195
- should "handle negative numbers" do
196
- assert_equal TimeOfDay.new(23,59,30), TimeOfDay.from_second_of_day(-30)
192
+ it "handles negative numbers" do
193
+ assert_equal Tod::TimeOfDay.new(23,59,30), Tod::TimeOfDay.from_second_of_day(-30)
197
194
  end
198
195
 
199
- should "handle negative numbers more than a day away" do
200
- assert_equal TimeOfDay.new(23,59,30), TimeOfDay.from_second_of_day(-86430)
196
+ it "handles negative numbers more than a day away" do
197
+ assert_equal Tod::TimeOfDay.new(23,59,30), Tod::TimeOfDay.from_second_of_day(-86430)
201
198
  end
202
199
 
203
- should "have alias from_i" do
204
- assert_equal TimeOfDay.method(:from_second_of_day), TimeOfDay.method(:from_i)
200
+ it "has alias from_i" do
201
+ assert_equal Tod::TimeOfDay.method(:from_second_of_day), Tod::TimeOfDay.method(:from_i)
205
202
  end
206
203
  end
207
204
 
208
- context "on" do
209
- should "be local Time on given date" do
210
- assert_equal Time.local(2010,12,29, 8,30), TimeOfDay.new(8,30).on(Date.civil(2010,12,29))
205
+ describe "on" do
206
+ it "is local Time on given date" do
207
+ assert_equal Time.zone.local(2010,12,29, 8,30), Tod::TimeOfDay.new(8,30).on(Date.civil(2010,12,29))
211
208
  end
212
209
 
213
- context "with a time zone" do
214
- should "be TimeWithZone on given date" do
210
+ describe "with a time zone" do
211
+ it "is TimeWithZone on given date" do
215
212
  date = Date.civil 2000,1,1
216
- tod = TimeOfDay.new 8,30
213
+ tod = Tod::TimeOfDay.new 8,30
217
214
  time_zone = ActiveSupport::TimeZone['Eastern Time (US & Canada)']
218
215
  assert_equal time_zone.local(2000,1,1, 8,30), tod.on(date, time_zone)
219
216
  end
@@ -1,18 +1,32 @@
1
1
  require File.expand_path(File.join(File.dirname(__FILE__),'..','test_helper'))
2
- require 'active_support/time'
3
2
 
4
- class TimeOfDayWithActiveSupportTest < Test::Unit::TestCase
5
- context "self.time_zone" do
6
- context "when Time.zone is nil" do
7
- should "be Time" do
8
- assert_equal Time, TimeOfDay.time_zone
3
+ describe "TimeOfDay with ActiveSupport" do
4
+ describe ".time_zone" do
5
+ before do
6
+ @orig_zone = Time.zone
7
+ end
8
+
9
+ after do
10
+ Time.zone = @orig_zone
11
+ end
12
+
13
+ describe "when Time.zone is nil" do
14
+ before do
15
+ Time.zone = nil
16
+ end
17
+
18
+ it "is Time" do
19
+ assert_equal Time, Tod::TimeOfDay.time_zone
9
20
  end
10
21
  end
11
22
 
12
- context "when Time.zone is set" do
13
- should "be Time.zone" do
23
+ describe "when Time.zone is set" do
24
+ before do
14
25
  Time.zone = "Central Time (US & Canada)"
15
- assert_equal Time.zone, TimeOfDay.time_zone
26
+ end
27
+
28
+ it "is Time.zone" do
29
+ assert_equal Time.zone, Tod::TimeOfDay.time_zone
16
30
  end
17
31
  end
18
32
  end
@@ -1,10 +1,10 @@
1
1
  require File.expand_path(File.join(File.dirname(__FILE__),'..','test_helper'))
2
2
 
3
- class TimeTest < Test::Unit::TestCase
4
- context "to_time_of_day" do
5
- should "be TimeOfDay" do
3
+ describe "Time extensions" do
4
+ describe "#to_time_of_day" do
5
+ it "is Tod::TimeOfDay" do
6
6
  time = Time.local 2000,1,1, 12,30,15
7
- assert_equal TimeOfDay.new(12,30,15), time.to_time_of_day
7
+ assert_equal Tod::TimeOfDay.new(12,30,15), time.to_time_of_day
8
8
  end
9
9
  end
10
10
  end
@@ -13,9 +13,7 @@ Gem::Specification.new do |s|
13
13
  s.description = %q{Supplies TimeOfDay and Shift class that includes parsing, strftime, comparison, and arithmetic.}
14
14
  s.license = 'MIT'
15
15
 
16
- s.add_development_dependency "test-unit"
17
- s.add_development_dependency "shoulda"
18
- s.add_development_dependency "mocha"
16
+ s.add_development_dependency "minitest"
19
17
  s.add_development_dependency "tzinfo"
20
18
  s.add_development_dependency "rake"
21
19
  s.add_development_dependency "activerecord", ">= 3.0.0"
metadata CHANGED
@@ -1,45 +1,17 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: tod
3
3
  version: !ruby/object:Gem::Version
4
- version: 1.5.0
4
+ version: 2.0.0
5
5
  platform: ruby
6
6
  authors:
7
7
  - Jack Christensen
8
8
  autorequire:
9
9
  bindir: bin
10
10
  cert_chain: []
11
- date: 2015-01-16 00:00:00.000000000 Z
11
+ date: 2015-04-18 00:00:00.000000000 Z
12
12
  dependencies:
13
13
  - !ruby/object:Gem::Dependency
14
- name: test-unit
15
- requirement: !ruby/object:Gem::Requirement
16
- requirements:
17
- - - ">="
18
- - !ruby/object:Gem::Version
19
- version: '0'
20
- type: :development
21
- prerelease: false
22
- version_requirements: !ruby/object:Gem::Requirement
23
- requirements:
24
- - - ">="
25
- - !ruby/object:Gem::Version
26
- version: '0'
27
- - !ruby/object:Gem::Dependency
28
- name: shoulda
29
- requirement: !ruby/object:Gem::Requirement
30
- requirements:
31
- - - ">="
32
- - !ruby/object:Gem::Version
33
- version: '0'
34
- type: :development
35
- prerelease: false
36
- version_requirements: !ruby/object:Gem::Requirement
37
- requirements:
38
- - - ">="
39
- - !ruby/object:Gem::Version
40
- version: '0'
41
- - !ruby/object:Gem::Dependency
42
- name: mocha
14
+ name: minitest
43
15
  requirement: !ruby/object:Gem::Requirement
44
16
  requirements:
45
17
  - - ">="
@@ -130,15 +102,15 @@ files:
130
102
  - gemfiles/4.2.gemfile
131
103
  - lib/tod.rb
132
104
  - lib/tod/conversions.rb
133
- - lib/tod/date.rb
105
+ - lib/tod/core_extensions.rb
106
+ - lib/tod/date_extensions.rb
134
107
  - lib/tod/mongoization.rb
135
108
  - lib/tod/shift.rb
136
- - lib/tod/time.rb
109
+ - lib/tod/time_extensions.rb
137
110
  - lib/tod/time_of_day.rb
138
111
  - lib/tod/version.rb
139
112
  - test/support/active_record.rb
140
113
  - test/test_helper.rb
141
- - test/tod/a_a_a_time_of_day_time_zone_without_active_support_test.rb
142
114
  - test/tod/conversion_test.rb
143
115
  - test/tod/date_test.rb
144
116
  - test/tod/shift_test.rb