gosu_enhanced 0.3.4 → 0.3.5

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.
Files changed (15) hide show
  1. checksums.yaml +4 -4
  2. data/Gemfile.lock +11 -8
  3. data/README.md +4 -4
  4. data/Rakefile +3 -3
  5. data/gosu_enhanced.gemspec +15 -15
  6. data/lib/gosu_enhanced/enhanced.rb +21 -19
  7. data/lib/gosu_enhanced/point.rb +38 -20
  8. data/lib/gosu_enhanced/region.rb +31 -14
  9. data/lib/gosu_enhanced/size.rb +66 -23
  10. data/lib/gosu_enhanced/version.rb +3 -2
  11. data/spec/point_spec.rb +77 -77
  12. data/spec/region_delegation_spec.rb +78 -78
  13. data/spec/region_spec.rb +40 -38
  14. data/spec/size_spec.rb +75 -75
  15. metadata +10 -10
data/spec/point_spec.rb CHANGED
@@ -3,120 +3,120 @@ require 'spec_helper'
3
3
  describe GosuEnhanced::Point do
4
4
  describe '#initialize' do
5
5
  it 'should work with two positive values' do
6
- point = GosuEnhanced::Point.new( 10, 20 )
7
- expect( point.x ).to eq 10
8
- expect( point.y ).to eq 20
6
+ point = GosuEnhanced::Point.new(10, 20)
7
+ expect(point.x).to eq 10
8
+ expect(point.y).to eq 20
9
9
  end
10
10
 
11
11
  it 'should work with negative values' do
12
- point = GosuEnhanced::Point.new( -10, 20 )
13
- expect( point.x ).to eq( -10 )
14
- expect( point.y ).to eq 20
12
+ point = GosuEnhanced::Point.new(-10, 20)
13
+ expect(point.x).to eq(-10)
14
+ expect(point.y).to eq 20
15
15
 
16
- point = GosuEnhanced::Point.new( 10, -20 )
17
- expect( point.x ).to eq 10
18
- expect( point.y ).to eq( -20 )
16
+ point = GosuEnhanced::Point.new(10, -20)
17
+ expect(point.x).to eq 10
18
+ expect(point.y).to eq(-20)
19
19
 
20
- point = GosuEnhanced::Point.new( -10, -20 )
21
- expect( point.x ).to eq( -10 )
22
- expect( point.y ).to eq( -20 )
20
+ point = GosuEnhanced::Point.new(-10, -20)
21
+ expect(point.x).to eq(-10)
22
+ expect(point.y).to eq(-20)
23
23
  end
24
24
  end
25
25
 
26
26
  describe '#offset' do
27
27
  it 'should work with another Point' do
28
- point = GosuEnhanced::Point.new( 10, 20 )
29
- opoint = point.offset( GosuEnhanced::Point.new( 30, 40 ) )
30
- expect( opoint.x ).to eq 40
31
- expect( opoint.y ).to eq 60
28
+ point = GosuEnhanced::Point.new(10, 20)
29
+ opoint = point.offset(GosuEnhanced::Point.new(30, 40))
30
+ expect(opoint.x).to eq 40
31
+ expect(opoint.y).to eq 60
32
32
  end
33
33
 
34
34
  it 'should work with a Size' do
35
- point = GosuEnhanced::Point.new( 10, 20 )
36
- opoint = point.offset( GosuEnhanced::Size.new( 50, 60 ) )
37
- expect( opoint.x ).to eq 60
38
- expect( opoint.y ).to eq 80
35
+ point = GosuEnhanced::Point.new(10, 20)
36
+ opoint = point.offset(GosuEnhanced::Size.new(50, 60))
37
+ expect(opoint.x).to eq 60
38
+ expect(opoint.y).to eq 80
39
39
  end
40
40
 
41
41
  it 'should work with two positive values' do
42
- point = GosuEnhanced::Point.new( 10, 20 )
43
- opoint = point.offset( 40, 50 )
44
- expect( opoint.x ).to eq 50
45
- expect( opoint.y ).to eq 70
42
+ point = GosuEnhanced::Point.new(10, 20)
43
+ opoint = point.offset(40, 50)
44
+ expect(opoint.x).to eq 50
45
+ expect(opoint.y).to eq 70
46
46
  end
47
47
 
48
48
  it 'should work with two negative values' do
49
- point = GosuEnhanced::Point.new( 60, 80 )
50
- opoint = point.offset( -40, -50 )
51
- expect( opoint.x ).to eq 20
52
- expect( opoint.y ).to eq 30
49
+ point = GosuEnhanced::Point.new(60, 80)
50
+ opoint = point.offset(-40, -50)
51
+ expect(opoint.x).to eq 20
52
+ expect(opoint.y).to eq 30
53
53
  end
54
54
 
55
55
  it 'should work with values that result in negative co-ordinates' do
56
- point = GosuEnhanced::Point.new( 60, 80 )
57
- opoint = point.offset( -80, -150 )
58
- expect( opoint.x ).to eq( -20 )
59
- expect( opoint.y ).to eq( -70 )
56
+ point = GosuEnhanced::Point.new(60, 80)
57
+ opoint = point.offset(-80, -150)
58
+ expect(opoint.x).to eq(-20)
59
+ expect(opoint.y).to eq(-70)
60
60
  end
61
61
  end
62
62
 
63
63
  describe '#move_by!' do
64
64
  it 'should work with another Point' do
65
- point = GosuEnhanced::Point.new( 10, 20 )
66
- point.move_by!( GosuEnhanced::Point.new( 30, 40 ) )
67
- expect( point.x ).to eq 40
68
- expect( point.y ).to eq 60
65
+ point = GosuEnhanced::Point.new(10, 20)
66
+ point.move_by!(GosuEnhanced::Point.new(30, 40))
67
+ expect(point.x).to eq 40
68
+ expect(point.y).to eq 60
69
69
  end
70
70
 
71
71
  it 'should work with a Size' do
72
- point = GosuEnhanced::Point.new( 10, 20 )
73
- point.move_by!( GosuEnhanced::Size.new( 40, 50 ) )
74
- expect( point.x ).to eq 50
75
- expect( point.y ).to eq 70
72
+ point = GosuEnhanced::Point.new(10, 20)
73
+ point.move_by!(GosuEnhanced::Size.new(40, 50))
74
+ expect(point.x).to eq 50
75
+ expect(point.y).to eq 70
76
76
  end
77
77
 
78
78
  it 'should work with two positive values' do
79
- point = GosuEnhanced::Point.new( 10, 20 )
80
- point.move_by!( 40, 50 )
81
- expect( point.x ).to eq 50
82
- expect( point.y ).to eq 70
79
+ point = GosuEnhanced::Point.new(10, 20)
80
+ point.move_by!(40, 50)
81
+ expect(point.x).to eq 50
82
+ expect(point.y).to eq 70
83
83
  end
84
84
 
85
85
  it 'should work with two negative values' do
86
- point = GosuEnhanced::Point.new( 60, 80 )
87
- point.move_by!( -40, -50 )
88
- expect( point.x ).to eq 20
89
- expect( point.y ).to eq 30
86
+ point = GosuEnhanced::Point.new(60, 80)
87
+ point.move_by!(-40, -50)
88
+ expect(point.x).to eq 20
89
+ expect(point.y).to eq 30
90
90
  end
91
91
 
92
92
  it 'should work with values that result in negative co-ordinates' do
93
- point = GosuEnhanced::Point.new( 60, 80 )
94
- point.move_by!( -80, -150 )
95
- expect( point.x ).to eq( -20 )
96
- expect( point.y ).to eq( -70 )
93
+ point = GosuEnhanced::Point.new(60, 80)
94
+ point.move_by!(-80, -150)
95
+ expect(point.x).to eq(-20)
96
+ expect(point.y).to eq(-70)
97
97
  end
98
98
  end
99
99
 
100
100
  describe '#move_to!' do
101
101
  it 'should work with another Point' do
102
- point = GosuEnhanced::Point.new( 10, 20 )
103
- point.move_to!( GosuEnhanced::Point.new( 30, 40 ) )
104
- expect( point.x ).to eq 30
105
- expect( point.y ).to eq 40
102
+ point = GosuEnhanced::Point.new(10, 20)
103
+ point.move_to!(GosuEnhanced::Point.new(30, 40))
104
+ expect(point.x).to eq 30
105
+ expect(point.y).to eq 40
106
106
  end
107
107
 
108
108
  it 'should work with two positive values' do
109
- point = GosuEnhanced::Point.new( 10, 20 )
110
- point.move_to!( 40, 50 )
111
- expect( point.x ).to eq 40
112
- expect( point.y ).to eq 50
109
+ point = GosuEnhanced::Point.new(10, 20)
110
+ point.move_to!(40, 50)
111
+ expect(point.x).to eq 40
112
+ expect(point.y).to eq 50
113
113
  end
114
114
 
115
115
  it 'should work with two negative values' do
116
- point = GosuEnhanced::Point.new( 60, 80 )
117
- point.move_to!( -40, -50 )
118
- expect( point.x ).to eq( -40 )
119
- expect( point.y ).to eq( -50 )
116
+ point = GosuEnhanced::Point.new(60, 80)
117
+ point.move_to!(-40, -50)
118
+ expect(point.x).to eq(-40)
119
+ expect(point.y).to eq(-50)
120
120
  end
121
121
  end
122
122
 
@@ -124,28 +124,28 @@ describe GosuEnhanced::Point do
124
124
 
125
125
  describe '#dup' do
126
126
  it 'should make a copy of the Point' do
127
- point = GosuEnhanced::Point.new( 10, 20 )
127
+ point = GosuEnhanced::Point.new(10, 20)
128
128
  npoint = point.dup
129
129
 
130
- expect( point.x ).to eq 10
131
- expect( point.y ).to eq 20
130
+ expect(point.x).to eq 10
131
+ expect(point.y).to eq 20
132
132
 
133
- expect( npoint.x ).to eq 10
134
- expect( npoint.y ).to eq 20
133
+ expect(npoint.x).to eq 10
134
+ expect(npoint.y).to eq 20
135
135
 
136
- npoint.move_to!( 40, 50 )
137
- expect( npoint.x ).to eq 40
138
- expect( npoint.y ).to eq 50
136
+ npoint.move_to!(40, 50)
137
+ expect(npoint.x).to eq 40
138
+ expect(npoint.y).to eq 50
139
139
 
140
- expect( point.x ).to eq 10
141
- expect( point.y ).to eq 20
140
+ expect(point.x).to eq 10
141
+ expect(point.y).to eq 20
142
142
  end
143
143
  end
144
-
144
+
145
145
  describe '#to_s' do
146
146
  it 'should render usefully.' do
147
- point = GosuEnhanced::Point.new( 10, 20 )
148
- expect( point.to_s ).to eq '#<struct GosuEnhanced::Point x=10, y=20>'
147
+ point = GosuEnhanced::Point.new(10, 20)
148
+ expect(point.to_s).to eq '#<struct GosuEnhanced::Point x=10, y=20>'
149
149
  end
150
150
  end
151
151
  end
data/spec/region_delegation_spec.rb CHANGED
@@ -1,161 +1,161 @@
1
1
  require 'spec_helper'
2
2
 
3
3
  describe GosuEnhanced::Region do
4
- let( :point ) { GosuEnhanced::Point.new( 10, 20 ) }
5
- let( :size ) { GosuEnhanced::Size.new( 30, 40 ) }
4
+ let(:point) { GosuEnhanced::Point.new(10, 20) }
5
+ let(:size) { GosuEnhanced::Size.new(30, 40) }
6
6
 
7
7
  describe '#x' do
8
8
  it 'should return the left (x) co-ordinate' do
9
- reg = GosuEnhanced::Region.new( point, size )
10
- expect( reg.x ).to eq 10
9
+ reg = GosuEnhanced::Region.new(point, size)
10
+ expect(reg.x).to eq 10
11
11
  end
12
12
  end
13
13
 
14
14
  describe '#y' do
15
15
  it 'should return the top (y) co-ordinate' do
16
- reg = GosuEnhanced::Region.new( point, size )
17
- expect( reg.y ).to eq 20
16
+ reg = GosuEnhanced::Region.new(point, size)
17
+ expect(reg.y).to eq 20
18
18
  end
19
19
  end
20
20
 
21
21
  describe '#width' do
22
22
  it 'should return the width' do
23
- reg = GosuEnhanced::Region.new( point, size )
24
- expect( reg.width ).to eq 30
23
+ reg = GosuEnhanced::Region.new(point, size)
24
+ expect(reg.width).to eq 30
25
25
  end
26
26
  end
27
27
 
28
28
  describe '#height' do
29
29
  it 'should return the height' do
30
- reg = GosuEnhanced::Region.new( point, size )
31
- expect( reg.height ).to eq 40
30
+ reg = GosuEnhanced::Region.new(point, size)
31
+ expect(reg.height).to eq 40
32
32
  end
33
33
  end
34
34
 
35
35
  describe '#move_by!' do
36
36
  it 'should work with a Point' do
37
- reg = GosuEnhanced::Region.new( point, size )
38
- reg.move_by!( GosuEnhanced::Point.new( 30, 40 ) )
39
- expect( reg.left ).to eq 40
40
- expect( reg.top ).to eq 60
37
+ reg = GosuEnhanced::Region.new(point, size)
38
+ reg.move_by!(GosuEnhanced::Point.new(30, 40))
39
+ expect(reg.left).to eq 40
40
+ expect(reg.top).to eq 60
41
41
 
42
42
  # The original point should not have been changed by the move_by!
43
- expect( point.x ).to eq 10
44
- expect( point.y ).to eq 20
43
+ expect(point.x).to eq 10
44
+ expect(point.y).to eq 20
45
45
  end
46
46
 
47
47
  it 'should work with a Size' do
48
- reg = GosuEnhanced::Region.new( point, size )
49
- reg.move_by!( GosuEnhanced::Size.new( 40, 50 ) )
50
- expect( reg.left ).to eq 50
51
- expect( reg.top ).to eq 70
48
+ reg = GosuEnhanced::Region.new(point, size)
49
+ reg.move_by!(GosuEnhanced::Size.new(40, 50))
50
+ expect(reg.left).to eq 50
51
+ expect(reg.top).to eq 70
52
52
  end
53
53
 
54
54
  it 'should work with two positive values' do
55
- reg = GosuEnhanced::Region.new( point, size )
56
- reg.move_by!( 40, 50 )
57
- expect( reg.left ).to eq 50
58
- expect( reg.top ).to eq 70
55
+ reg = GosuEnhanced::Region.new(point, size)
56
+ reg.move_by!(40, 50)
57
+ expect(reg.left).to eq 50
58
+ expect(reg.top).to eq 70
59
59
  end
60
60
 
61
61
  it 'should work with two negative values' do
62
- reg = GosuEnhanced::Region.new( point, size )
63
- reg.move_by!( -5, -10 )
64
- expect( reg.left ).to eq 5
65
- expect( reg.top ).to eq 10
62
+ reg = GosuEnhanced::Region.new(point, size)
63
+ reg.move_by!(-5, -10)
64
+ expect(reg.left).to eq 5
65
+ expect(reg.top).to eq 10
66
66
  end
67
67
 
68
68
  it 'should work with values that result in negative co-ordinates' do
69
- reg = GosuEnhanced::Region.new( point, size )
70
- reg.move_by!( -80, -150 )
71
- expect( reg.left ).to eq( -70 )
72
- expect( reg.top ).to eq( -130 )
69
+ reg = GosuEnhanced::Region.new(point, size)
70
+ reg.move_by!(-80, -150)
71
+ expect(reg.left).to eq(-70)
72
+ expect(reg.top).to eq(-130)
73
73
  end
74
74
  end
75
75
 
76
76
  describe '#move_to!' do
77
77
  it 'should work with a Point' do
78
- reg = GosuEnhanced::Region.new( point, size )
79
- reg.move_to!( GosuEnhanced::Point.new( 30, 40 ) )
80
- expect( reg.left ).to eq 30
81
- expect( reg.top ).to eq 40
78
+ reg = GosuEnhanced::Region.new(point, size)
79
+ reg.move_to!(GosuEnhanced::Point.new(30, 40))
80
+ expect(reg.left).to eq 30
81
+ expect(reg.top).to eq 40
82
82
 
83
- expect( point.x ).to eq 10
84
- expect( point.y ).to eq 20
83
+ expect(point.x).to eq 10
84
+ expect(point.y).to eq 20
85
85
  end
86
86
 
87
87
  it 'should work with two positive values' do
88
- reg = GosuEnhanced::Region.new( point, size )
89
- reg.move_to!( 40, 50 )
90
- expect( reg.left ).to eq 40
91
- expect( reg.top ).to eq 50
88
+ reg = GosuEnhanced::Region.new(point, size)
89
+ reg.move_to!(40, 50)
90
+ expect(reg.left).to eq 40
91
+ expect(reg.top).to eq 50
92
92
  end
93
93
 
94
94
  it 'should work with two negative values' do
95
- reg = GosuEnhanced::Region.new( point, size )
96
- reg.move_to!( -5, -10 )
97
- expect( reg.left ).to eq( -5 )
98
- expect( reg.top ).to eq( -10 )
95
+ reg = GosuEnhanced::Region.new(point, size)
96
+ reg.move_to!(-5, -10)
97
+ expect(reg.left).to eq(-5)
98
+ expect(reg.top).to eq(-10)
99
99
  end
100
100
  end
101
101
 
102
102
  describe '#inflate!' do
103
103
  it 'should work with a Size' do
104
- reg = GosuEnhanced::Region.new( point, size )
105
- reg.inflate!( GosuEnhanced::Size.new( 30, 40 ) )
106
- expect( reg.width ).to eq 60
107
- expect( reg.height ).to eq 80
104
+ reg = GosuEnhanced::Region.new(point, size)
105
+ reg.inflate!(GosuEnhanced::Size.new(30, 40))
106
+ expect(reg.width).to eq 60
107
+ expect(reg.height).to eq 80
108
108
 
109
109
  # The original size should not have been changed by the inflate!
110
- expect( size.width ).to eq 30
111
- expect( size.height ).to eq 40
110
+ expect(size.width).to eq 30
111
+ expect(size.height).to eq 40
112
112
  end
113
113
 
114
114
  it 'should work with two values' do
115
- reg = GosuEnhanced::Region.new( point, size )
116
- reg.inflate!( 40, 50 )
117
- expect( reg.width ).to eq 70
118
- expect( reg.height ).to eq 90
115
+ reg = GosuEnhanced::Region.new(point, size)
116
+ reg.inflate!(40, 50)
117
+ expect(reg.width).to eq 70
118
+ expect(reg.height).to eq 90
119
119
  end
120
120
 
121
121
  it 'should work with negative values' do
122
- reg = GosuEnhanced::Region.new( point, size )
123
- reg.inflate!( -20, -35 )
124
- expect( reg.width ).to eq 10
125
- expect( reg.height ).to eq 5
122
+ reg = GosuEnhanced::Region.new(point, size)
123
+ reg.inflate!(-20, -35)
124
+ expect(reg.width).to eq 10
125
+ expect(reg.height).to eq 5
126
126
  end
127
127
 
128
128
  it 'should raise an error with out-of-range values' do
129
- reg = GosuEnhanced::Region.new( point, size )
130
- expect { reg.inflate!( -50, -20 ) }.to raise_error Exception
131
- expect { reg.inflate!( -25, -60 ) }.to raise_error Exception
132
- expect { reg.inflate!( -50, -70 ) }.to raise_error Exception
129
+ reg = GosuEnhanced::Region.new(point, size)
130
+ expect { reg.inflate!(-50, -20) }.to raise_error Exception
131
+ expect { reg.inflate!(-25, -60) }.to raise_error Exception
132
+ expect { reg.inflate!(-50, -70) }.to raise_error Exception
133
133
  end
134
134
  end
135
135
 
136
136
  describe '#deflate!' do
137
137
  it 'should work with a Size' do
138
- reg = GosuEnhanced::Region.new( point, size )
139
- reg.deflate!( GosuEnhanced::Size.new( 20, 35 ) )
140
- expect( reg.width ).to eq 10
141
- expect( reg.height ).to eq 5
138
+ reg = GosuEnhanced::Region.new(point, size)
139
+ reg.deflate!(GosuEnhanced::Size.new(20, 35))
140
+ expect(reg.width).to eq 10
141
+ expect(reg.height).to eq 5
142
142
 
143
- expect( size.width ).to eq 30
144
- expect( size.height ).to eq 40
143
+ expect(size.width).to eq 30
144
+ expect(size.height).to eq 40
145
145
  end
146
146
 
147
147
  it 'should work with two values' do
148
- reg = GosuEnhanced::Region.new( point, size )
149
- reg.deflate!( 10, 25 )
150
- expect( reg.width ).to eq 20
151
- expect( reg.height ).to eq 15
148
+ reg = GosuEnhanced::Region.new(point, size)
149
+ reg.deflate!(10, 25)
150
+ expect(reg.width).to eq 20
151
+ expect(reg.height).to eq 15
152
152
  end
153
153
 
154
154
  it 'should raise an error for out-of-range values' do
155
- reg = GosuEnhanced::Region.new( point, size )
156
- expect { reg.deflate!( 25, 50 ) }.to raise_error Exception
157
- expect { reg.deflate!( 60, 35 ) }.to raise_error Exception
158
- expect { reg.deflate!( 80, 70 ) }.to raise_error Exception
155
+ reg = GosuEnhanced::Region.new(point, size)
156
+ expect { reg.deflate!(25, 50) }.to raise_error Exception
157
+ expect { reg.deflate!(60, 35) }.to raise_error Exception
158
+ expect { reg.deflate!(80, 70) }.to raise_error Exception
159
159
  end
160
160
  end
161
161
  end
data/spec/region_spec.rb CHANGED
@@ -1,58 +1,58 @@
1
1
  require 'spec_helper'
2
2
 
3
3
  describe GosuEnhanced::Region do
4
- let( :point ) { GosuEnhanced::Point.new( 10, 20 ) }
5
- let( :size ) { GosuEnhanced::Size.new( 30, 40 ) }
4
+ let(:point) { GosuEnhanced::Point.new(10, 20) }
5
+ let(:size) { GosuEnhanced::Size.new(30, 40) }
6
6
 
7
7
  describe '#initialize' do
8
8
  it 'should work with a Point and a Size' do
9
- GosuEnhanced::Region.new( point, size )
9
+ GosuEnhanced::Region.new(point, size)
10
10
  end
11
11
  end
12
12
 
13
13
  describe '#position' do
14
14
  it 'should return the position as a Point' do
15
- reg = GosuEnhanced::Region.new( point, size )
16
- expect( reg.position ).to eq GosuEnhanced::Point.new( 10, 20 )
15
+ reg = GosuEnhanced::Region.new(point, size)
16
+ expect(reg.position).to eq GosuEnhanced::Point.new(10, 20)
17
17
  end
18
18
  end
19
19
 
20
20
  describe '#top' do
21
21
  it 'should return the top co-ordinate' do
22
- reg = GosuEnhanced::Region.new( point, size )
23
- expect( reg.top ).to eq 20
22
+ reg = GosuEnhanced::Region.new(point, size)
23
+ expect(reg.top).to eq 20
24
24
  end
25
25
  end
26
26
 
27
27
  describe '#left' do
28
28
  it 'should return the left co-ordinate' do
29
- reg = GosuEnhanced::Region.new( point, size )
30
- expect( reg.left ).to eq 10
29
+ reg = GosuEnhanced::Region.new(point, size)
30
+ expect(reg.left).to eq 10
31
31
  end
32
32
  end
33
33
 
34
34
  describe '#size' do
35
35
  it 'should return the size as a Size' do
36
- reg = GosuEnhanced::Region.new( point, size )
37
- expect( reg.size ).to eq GosuEnhanced::Size.new( 30, 40 )
36
+ reg = GosuEnhanced::Region.new(point, size)
37
+ expect(reg.size).to eq GosuEnhanced::Size.new(30, 40)
38
38
  end
39
39
  end
40
40
 
41
41
  describe '#contains?' do
42
42
  it 'should work with two co-ordinates' do
43
- reg = GosuEnhanced::Region.new( point, size )
44
- expect( reg.contains?( 10, 20 ) ).to be true
45
- expect( reg.contains?( 20, 35 ) ).to be true
46
- expect( reg.contains?( 29, 59 ) ).to be true
47
- expect( reg.contains?( 30, 60 ) ).to be false
43
+ reg = GosuEnhanced::Region.new(point, size)
44
+ expect(reg.contains?(10, 20)).to be true
45
+ expect(reg.contains?(20, 35)).to be true
46
+ expect(reg.contains?(29, 59)).to be true
47
+ expect(reg.contains?(30, 60)).to be false
48
48
  end
49
49
 
50
50
  it 'should work with a Point' do
51
- reg = GosuEnhanced::Region.new( point, size )
52
- expect( reg.contains?( GosuEnhanced::Point.new( 10, 20 ) ) ).to be true
53
- expect( reg.contains?( GosuEnhanced::Point.new( 20, 35 ) ) ).to be true
54
- expect( reg.contains?( GosuEnhanced::Point.new( 29, 59 ) ) ).to be true
55
- expect( reg.contains?( GosuEnhanced::Point.new( 30, 60 ) ) ).to be false
51
+ reg = GosuEnhanced::Region.new(point, size)
52
+ expect(reg.contains?(GosuEnhanced::Point.new(10, 20))).to be true
53
+ expect(reg.contains?(GosuEnhanced::Point.new(20, 35))).to be true
54
+ expect(reg.contains?(GosuEnhanced::Point.new(29, 59))).to be true
55
+ expect(reg.contains?(GosuEnhanced::Point.new(30, 60))).to be false
56
56
  end
57
57
  end
58
58
 
@@ -61,32 +61,34 @@ describe GosuEnhanced::Region do
61
61
 
62
62
  describe '#dup' do
63
63
  it 'should duplicate a region' do
64
- reg = GosuEnhanced::Region.new( point, size )
64
+ reg = GosuEnhanced::Region.new(point, size)
65
65
  new_reg = reg.dup
66
66
 
67
- expect( reg.position ).to eq GosuEnhanced::Point.new( 10, 20 )
68
- expect( reg.size ).to eq GosuEnhanced::Size.new( 30, 40 )
67
+ expect(reg.position).to eq GosuEnhanced::Point.new(10, 20)
68
+ expect(reg.size).to eq GosuEnhanced::Size.new(30, 40)
69
69
 
70
- expect( new_reg.position ).to eq GosuEnhanced::Point.new( 10, 20 )
71
- expect( new_reg.size ).to eq GosuEnhanced::Size.new( 30, 40 )
70
+ expect(new_reg.position).to eq GosuEnhanced::Point.new(10, 20)
71
+ expect(new_reg.size).to eq GosuEnhanced::Size.new(30, 40)
72
72
 
73
- new_reg.move_to!( 20, 30 )
74
- new_reg.inflate!( 10, 10 )
75
- expect( new_reg.position ).to eq GosuEnhanced::Point.new( 20, 30 )
76
- expect( new_reg.size ).to eq GosuEnhanced::Size.new( 40, 50 )
73
+ new_reg.move_to!(20, 30)
74
+ new_reg.inflate!(10, 10)
75
+ expect(new_reg.position).to eq GosuEnhanced::Point.new(20, 30)
76
+ expect(new_reg.size).to eq GosuEnhanced::Size.new(40, 50)
77
77
 
78
- expect( reg.position ).to eq GosuEnhanced::Point.new( 10, 20 )
79
- expect( reg.size ).to eq GosuEnhanced::Size.new( 30, 40 )
78
+ expect(reg.position).to eq GosuEnhanced::Point.new(10, 20)
79
+ expect(reg.size).to eq GosuEnhanced::Size.new(30, 40)
80
80
  end
81
81
  end
82
-
82
+
83
83
  describe '#to_s' do
84
84
  it 'should render usefully' do
85
- point = GosuEnhanced::Point.new( 10, 20 )
86
- size = GosuEnhanced::Size.new( 30, 40 )
87
- region = GosuEnhanced::Region.new( point, size )
88
-
89
- expect( region.to_s ).to eq '<GosuEnhanced::Region: #<struct GosuEnhanced::Point x=10, y=20>, <GosuEnhanced::Size 30x40>>'
85
+ point = GosuEnhanced::Point.new(10, 20)
86
+ size = GosuEnhanced::Size.new(30, 40)
87
+ region = GosuEnhanced::Region.new(point, size)
88
+
89
+ expect(region.to_s).to eq '<GosuEnhanced::Region: ' \
90
+ '#<struct GosuEnhanced::Point x=10, y=20>' \
91
+ ', <GosuEnhanced::Size 30x40>>'
90
92
  end
91
93
  end
92
94
  end