cascading_configuration 1.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.
- data/CHANGELOG.md +40 -0
- data/README.md +211 -0
- data/lib/cascading_configuration/array/sorted/unique.rb +110 -0
- data/lib/cascading_configuration/array/sorted.rb +106 -0
- data/lib/cascading_configuration/array/unique.rb +106 -0
- data/lib/cascading_configuration/array.rb +103 -0
- data/lib/cascading_configuration/core/enable_instance_support.rb +22 -0
- data/lib/cascading_configuration/core/enable_module_support.rb +24 -0
- data/lib/cascading_configuration/core/encapsulation.rb +343 -0
- data/lib/cascading_configuration/core/instance_controller/extension_module.rb +38 -0
- data/lib/cascading_configuration/core/instance_controller/support_module/instance_support_module.rb +21 -0
- data/lib/cascading_configuration/core/instance_controller/support_module/singleton_support_module.rb +21 -0
- data/lib/cascading_configuration/core/instance_controller/support_module.rb +253 -0
- data/lib/cascading_configuration/core/instance_controller.rb +840 -0
- data/lib/cascading_configuration/core/module/block_configurations/cascading_variables.rb +129 -0
- data/lib/cascading_configuration/core/module/block_configurations.rb +15 -0
- data/lib/cascading_configuration/core/module/extended_configurations/compositing_objects.rb +173 -0
- data/lib/cascading_configuration/core/module/extended_configurations.rb +65 -0
- data/lib/cascading_configuration/core/module/inheriting_values.rb +64 -0
- data/lib/cascading_configuration/core/module.rb +284 -0
- data/lib/cascading_configuration/core.rb +23 -0
- data/lib/cascading_configuration/hash.rb +103 -0
- data/lib/cascading_configuration/setting.rb +87 -0
- data/lib/cascading_configuration.rb +47 -0
- data/lib/namespaces.rb +9 -0
- data/lib/requires.rb +46 -0
- data/spec/cascading_configuration/array/sorted/unique_spec.rb +742 -0
- data/spec/cascading_configuration/array/sorted_spec.rb +741 -0
- data/spec/cascading_configuration/array/unique_spec.rb +746 -0
- data/spec/cascading_configuration/array_spec.rb +768 -0
- data/spec/cascading_configuration/core/encapsulation_spec.rb +208 -0
- data/spec/cascading_configuration/core/instance_controller/extension_module_spec.rb +26 -0
- data/spec/cascading_configuration/core/instance_controller/support_module_spec.rb +269 -0
- data/spec/cascading_configuration/core/instance_controller_spec.rb +273 -0
- data/spec/cascading_configuration/core/module/block_configurations/cascading_variables_spec.rb +17 -0
- data/spec/cascading_configuration/core/module/extended_configurations/compositing_objects_spec.rb +127 -0
- data/spec/cascading_configuration/core/module/extended_configurations_spec.rb +37 -0
- data/spec/cascading_configuration/core/module/inheriting_values_spec.rb +87 -0
- data/spec/cascading_configuration/core/module_spec.rb +491 -0
- data/spec/cascading_configuration/hash_spec.rb +826 -0
- data/spec/cascading_configuration/setting_spec.rb +687 -0
- data/spec/cascading_configuration_spec.rb +58 -0
- metadata +185 -0
|
@@ -0,0 +1,826 @@
|
|
|
1
|
+
|
|
2
|
+
require_relative '../../lib/cascading_configuration.rb'
|
|
3
|
+
|
|
4
|
+
describe CascadingConfiguration::Hash do
|
|
5
|
+
|
|
6
|
+
###############
|
|
7
|
+
# attr_hash #
|
|
8
|
+
###############
|
|
9
|
+
|
|
10
|
+
it 'can define a configuration hash, which is the primary interface' do
|
|
11
|
+
|
|
12
|
+
# possibilities:
|
|
13
|
+
# * module extended with setting
|
|
14
|
+
# => singleton gets attr_setting and configurations
|
|
15
|
+
# => including modules and classes get nothing
|
|
16
|
+
# => extending modules and classes get nothing
|
|
17
|
+
# => instances of including and extending classes get nothing
|
|
18
|
+
# * module included with setting
|
|
19
|
+
# => singleton gets attr_setting and configurations
|
|
20
|
+
# => including modules and classes get attr_setting and configurations
|
|
21
|
+
# => instances of including classes get configurations
|
|
22
|
+
# => extending modules and classes get attr_setting and configurations
|
|
23
|
+
# => instances of extending classes get nothing
|
|
24
|
+
module ::CascadingConfiguration::Hash::ConfigurationMockModuleExtended
|
|
25
|
+
extend CascadingConfiguration::Hash
|
|
26
|
+
# => singleton gets attr_setting and configurations
|
|
27
|
+
respond_to?( :attr_hash ).should == true
|
|
28
|
+
respond_to?( :attr_configuration_hash ).should == true
|
|
29
|
+
attr_hash :configuration_setting, :some_other_hash
|
|
30
|
+
respond_to?( :configuration_setting ).should == true
|
|
31
|
+
configuration_setting.should == {}
|
|
32
|
+
self.configuration_setting[ :a_configuration ] = :some_value
|
|
33
|
+
configuration_setting.should == { :a_configuration => :some_value }
|
|
34
|
+
method_defined?( :configuration_setting ).should == false
|
|
35
|
+
instance_variables.empty?.should == true
|
|
36
|
+
# => including modules and classes get nothing
|
|
37
|
+
module SubmoduleIncluding
|
|
38
|
+
include CascadingConfiguration::Hash::ConfigurationMockModuleExtended
|
|
39
|
+
method_defined?( :configuration_setting ).should == false
|
|
40
|
+
respond_to?( :configuration_setting ).should == false
|
|
41
|
+
instance_variables.empty?.should == true
|
|
42
|
+
end
|
|
43
|
+
# => extending modules and classes get nothing
|
|
44
|
+
module SubmoduleExtending
|
|
45
|
+
extend CascadingConfiguration::Hash::ConfigurationMockModuleExtended
|
|
46
|
+
method_defined?( :configuration_setting ).should == false
|
|
47
|
+
respond_to?( :configuration_setting ).should == false
|
|
48
|
+
instance_variables.empty?.should == true
|
|
49
|
+
end
|
|
50
|
+
# => instances of including and extending classes get nothing
|
|
51
|
+
class ClassIncluding
|
|
52
|
+
include CascadingConfiguration::Hash::ConfigurationMockModuleExtended
|
|
53
|
+
method_defined?( :configuration_setting ).should == false
|
|
54
|
+
respond_to?( :configuration_setting ).should == false
|
|
55
|
+
instance_variables.empty?.should == true
|
|
56
|
+
end
|
|
57
|
+
class ClassExtending
|
|
58
|
+
extend CascadingConfiguration::Hash::ConfigurationMockModuleExtended
|
|
59
|
+
method_defined?( :configuration_setting ).should == false
|
|
60
|
+
respond_to?( :configuration_setting ).should == false
|
|
61
|
+
instance_variables.empty?.should == true
|
|
62
|
+
end
|
|
63
|
+
end
|
|
64
|
+
|
|
65
|
+
# * module included with setting
|
|
66
|
+
module ::CascadingConfiguration::Hash::ConfigurationMockModuleIncluded
|
|
67
|
+
include CascadingConfiguration::Hash
|
|
68
|
+
# => singleton gets attr_setting and configurations
|
|
69
|
+
respond_to?( :attr_hash ).should == true
|
|
70
|
+
attr_hash :configuration_setting
|
|
71
|
+
respond_to?( :configuration_setting ).should == true
|
|
72
|
+
configuration_setting.should == {}
|
|
73
|
+
self.configuration_setting[ :a_configuration ] = :some_value
|
|
74
|
+
configuration_setting.should == { :a_configuration => :some_value }
|
|
75
|
+
method_defined?( :configuration_setting ).should == true
|
|
76
|
+
instance_variables.empty?.should == true
|
|
77
|
+
# => including modules and classes get attr_setting and configurations
|
|
78
|
+
module SubmoduleIncluding
|
|
79
|
+
include CascadingConfiguration::Hash::ConfigurationMockModuleIncluded
|
|
80
|
+
method_defined?( :configuration_setting ).should == true
|
|
81
|
+
respond_to?( :configuration_setting ).should == true
|
|
82
|
+
configuration_setting.should == { :a_configuration => :some_value }
|
|
83
|
+
configuration_setting[ :other_setting ] = :some_value
|
|
84
|
+
configuration_setting.should == { :a_configuration => :some_value,
|
|
85
|
+
:other_setting => :some_value }
|
|
86
|
+
configuration_setting.delete( :other_setting ).should == :some_value
|
|
87
|
+
configuration_setting.should == { :a_configuration => :some_value }
|
|
88
|
+
instance_variables.empty?.should == true
|
|
89
|
+
end
|
|
90
|
+
# => extending modules and classes get attr_setting and configurations
|
|
91
|
+
module SubmoduleExtending
|
|
92
|
+
extend CascadingConfiguration::Hash::ConfigurationMockModuleIncluded
|
|
93
|
+
# if we're extended then we want to use the eigenclass ancestor chain
|
|
94
|
+
# - the first ancestor will be the extending module
|
|
95
|
+
# - the rest of the ancestors will be the extending module's include chain
|
|
96
|
+
respond_to?( :configuration_setting ).should == true
|
|
97
|
+
configuration_setting.should == { :a_configuration => :some_value }
|
|
98
|
+
configuration_setting[ :other_setting ] = :some_value
|
|
99
|
+
configuration_setting.should == { :a_configuration => :some_value,
|
|
100
|
+
:other_setting => :some_value }
|
|
101
|
+
configuration_setting.delete( :other_setting ).should == :some_value
|
|
102
|
+
configuration_setting.should == { :a_configuration => :some_value }
|
|
103
|
+
method_defined?( :configuration_setting ).should == false
|
|
104
|
+
instance_variables.empty?.should == true
|
|
105
|
+
end
|
|
106
|
+
# => instances of including classes get configurations
|
|
107
|
+
class ClassIncluding
|
|
108
|
+
include CascadingConfiguration::Hash::ConfigurationMockModuleIncluded
|
|
109
|
+
method_defined?( :configuration_setting ).should == true
|
|
110
|
+
respond_to?( :configuration_setting ).should == true
|
|
111
|
+
configuration_setting.should == { :a_configuration => :some_value }
|
|
112
|
+
configuration_setting[ :other_setting ] = :some_value
|
|
113
|
+
configuration_setting.should == { :a_configuration => :some_value,
|
|
114
|
+
:other_setting => :some_value }
|
|
115
|
+
configuration_setting.delete( :other_setting ).should == :some_value
|
|
116
|
+
configuration_setting.should == { :a_configuration => :some_value }
|
|
117
|
+
instance_variables.empty?.should == true
|
|
118
|
+
end
|
|
119
|
+
setting_class_including_instance = ClassIncluding.new
|
|
120
|
+
setting_class_including_instance.respond_to?( :configuration_setting ).should == true
|
|
121
|
+
setting_class_including_instance.configuration_setting.should == { :a_configuration => :some_value }
|
|
122
|
+
setting_class_including_instance.configuration_setting.delete( :a_configuration )
|
|
123
|
+
setting_class_including_instance.instance_variables.empty?.should == true
|
|
124
|
+
class ClassExtending
|
|
125
|
+
extend CascadingConfiguration::Hash::ConfigurationMockModuleIncluded
|
|
126
|
+
respond_to?( :configuration_setting ).should == true
|
|
127
|
+
configuration_setting.should == { :a_configuration => :some_value }
|
|
128
|
+
configuration_setting[ :other_setting ] = :some_value
|
|
129
|
+
configuration_setting.should == { :a_configuration => :some_value,
|
|
130
|
+
:other_setting => :some_value }
|
|
131
|
+
configuration_setting.delete( :other_setting ).should == :some_value
|
|
132
|
+
configuration_setting.should == { :a_configuration => :some_value }
|
|
133
|
+
instance_variables.empty?.should == true
|
|
134
|
+
end
|
|
135
|
+
setting_class_including_instance = ClassExtending.new
|
|
136
|
+
setting_class_including_instance.respond_to?( :configuration_setting ).should == false
|
|
137
|
+
setting_class_including_instance.instance_variables.empty?.should == true
|
|
138
|
+
end
|
|
139
|
+
|
|
140
|
+
class CascadingConfiguration::Hash::ConfigurationMockClass
|
|
141
|
+
include CascadingConfiguration::Hash::ConfigurationMockModuleIncluded::SubmoduleIncluding
|
|
142
|
+
configuration_setting.should == { :a_configuration => :some_value }
|
|
143
|
+
configuration_setting[ :other_setting ] = :some_value
|
|
144
|
+
configuration_setting.should == { :a_configuration => :some_value,
|
|
145
|
+
:other_setting => :some_value }
|
|
146
|
+
configuration_setting.delete( :other_setting ).should == :some_value
|
|
147
|
+
configuration_setting.should == { :a_configuration => :some_value }
|
|
148
|
+
instance_variables.empty?.should == true
|
|
149
|
+
end
|
|
150
|
+
|
|
151
|
+
object_instance_one = CascadingConfiguration::Hash::ConfigurationMockClass.new
|
|
152
|
+
object_instance_one.configuration_setting.should == { :a_configuration => :some_value }
|
|
153
|
+
object_instance_one.configuration_setting[ :some_other_configuration ] = :some_value
|
|
154
|
+
object_instance_one.configuration_setting.should == { :a_configuration => :some_value,
|
|
155
|
+
:some_other_configuration => :some_value }
|
|
156
|
+
object_instance_one.instance_variables.empty?.should == true
|
|
157
|
+
|
|
158
|
+
class CascadingConfiguration::Hash::ConfigurationMockClassSub1 < CascadingConfiguration::Hash::ConfigurationMockClass
|
|
159
|
+
configuration_setting.should == { :a_configuration => :some_value }
|
|
160
|
+
self.configuration_setting[ :another_configuration ] = :some_value
|
|
161
|
+
configuration_setting.should == { :a_configuration => :some_value,
|
|
162
|
+
:another_configuration => :some_value }
|
|
163
|
+
instance_variables.empty?.should == true
|
|
164
|
+
end
|
|
165
|
+
|
|
166
|
+
object_instance_two = CascadingConfiguration::Hash::ConfigurationMockClassSub1.new
|
|
167
|
+
object_instance_two.configuration_setting.should == { :a_configuration => :some_value,
|
|
168
|
+
:another_configuration => :some_value }
|
|
169
|
+
object_instance_two.configuration_setting[ :some_other_configuration ] = :some_value
|
|
170
|
+
object_instance_two.configuration_setting.should == { :a_configuration => :some_value,
|
|
171
|
+
:another_configuration => :some_value,
|
|
172
|
+
:some_other_configuration => :some_value }
|
|
173
|
+
object_instance_two.instance_variables.empty?.should == true
|
|
174
|
+
|
|
175
|
+
# change ancestor setting
|
|
176
|
+
CascadingConfiguration::Hash::ConfigurationMockClass.configuration_setting[ :a_yet_unused_configuration ] = :some_value
|
|
177
|
+
CascadingConfiguration::Hash::ConfigurationMockClass.configuration_setting.should == { :a_configuration => :some_value,
|
|
178
|
+
:a_yet_unused_configuration => :some_value }
|
|
179
|
+
object_instance_one.configuration_setting.should == { :a_configuration => :some_value,
|
|
180
|
+
:a_yet_unused_configuration => :some_value,
|
|
181
|
+
:some_other_configuration => :some_value }
|
|
182
|
+
CascadingConfiguration::Hash::ConfigurationMockClassSub1.configuration_setting.should == { :a_configuration => :some_value,
|
|
183
|
+
:a_yet_unused_configuration => :some_value,
|
|
184
|
+
:another_configuration => :some_value }
|
|
185
|
+
object_instance_two.configuration_setting.should == { :a_configuration => :some_value,
|
|
186
|
+
:a_yet_unused_configuration => :some_value,
|
|
187
|
+
:another_configuration => :some_value,
|
|
188
|
+
:some_other_configuration => :some_value }
|
|
189
|
+
|
|
190
|
+
# freeze ancestor setting
|
|
191
|
+
object_instance_one.configuration_setting.freeze!
|
|
192
|
+
object_instance_one.configuration_setting.should == { :a_configuration => :some_value,
|
|
193
|
+
:a_yet_unused_configuration => :some_value,
|
|
194
|
+
:some_other_configuration => :some_value }
|
|
195
|
+
CascadingConfiguration::Hash::ConfigurationMockClassSub1.configuration_setting.freeze!
|
|
196
|
+
CascadingConfiguration::Hash::ConfigurationMockClassSub1.configuration_setting.should == { :a_configuration => :some_value,
|
|
197
|
+
:a_yet_unused_configuration => :some_value,
|
|
198
|
+
:another_configuration => :some_value }
|
|
199
|
+
CascadingConfiguration::Hash::ConfigurationMockClass.configuration_setting[ :non_cascading_configuration ] = :some_value
|
|
200
|
+
CascadingConfiguration::Hash::ConfigurationMockClass.configuration_setting.should == { :a_configuration => :some_value,
|
|
201
|
+
:a_yet_unused_configuration => :some_value,
|
|
202
|
+
:non_cascading_configuration => :some_value }
|
|
203
|
+
object_instance_one.configuration_setting.should == { :a_configuration => :some_value,
|
|
204
|
+
:a_yet_unused_configuration => :some_value,
|
|
205
|
+
:some_other_configuration => :some_value }
|
|
206
|
+
CascadingConfiguration::Hash::ConfigurationMockClassSub1.configuration_setting.should == { :a_configuration => :some_value,
|
|
207
|
+
:a_yet_unused_configuration => :some_value,
|
|
208
|
+
:another_configuration => :some_value }
|
|
209
|
+
object_instance_two.configuration_setting.should == { :a_configuration => :some_value,
|
|
210
|
+
:a_yet_unused_configuration => :some_value,
|
|
211
|
+
:another_configuration => :some_value,
|
|
212
|
+
:some_other_configuration => :some_value }
|
|
213
|
+
|
|
214
|
+
module ::CascadingConfiguration::Hash::ConfigurationMockModule
|
|
215
|
+
include CascadingConfiguration::Hash
|
|
216
|
+
attr_hash :some_hash do
|
|
217
|
+
def merge!( other_hash )
|
|
218
|
+
other_hash.each do |key, foreign_value|
|
|
219
|
+
if existing_value = self[ key ]
|
|
220
|
+
self[ key ] = foreign_value - existing_value
|
|
221
|
+
else
|
|
222
|
+
self[ key ] = foreign_value
|
|
223
|
+
end
|
|
224
|
+
end
|
|
225
|
+
end
|
|
226
|
+
end
|
|
227
|
+
self.some_hash = { :one => 1, :two => 2 }
|
|
228
|
+
self.some_hash.should == { :one => 1, :two => 2 }
|
|
229
|
+
end
|
|
230
|
+
|
|
231
|
+
module ::CascadingConfiguration::Hash::ConfigurationMockModule2
|
|
232
|
+
include CascadingConfiguration::Hash::ConfigurationMockModule
|
|
233
|
+
self.some_hash.should == { :one => 1, :two => 2 }
|
|
234
|
+
self.some_hash.merge!( { :one => 1, :two => 2 } )
|
|
235
|
+
self.some_hash.should == { :one => 0, :two => 0 }
|
|
236
|
+
end
|
|
237
|
+
|
|
238
|
+
end
|
|
239
|
+
|
|
240
|
+
######################
|
|
241
|
+
# attr_module_hash #
|
|
242
|
+
# attr_class_hash #
|
|
243
|
+
######################
|
|
244
|
+
|
|
245
|
+
it 'can define a class configuration hash, which will not cascade to instances' do
|
|
246
|
+
|
|
247
|
+
# possibilities:
|
|
248
|
+
# * module extended with setting
|
|
249
|
+
# => singleton gets attr_setting and configurations
|
|
250
|
+
# => including modules and classes get nothing
|
|
251
|
+
# => extending modules and classes get nothing
|
|
252
|
+
# => instances of including and extending classes get nothing
|
|
253
|
+
# * module included with setting
|
|
254
|
+
# => singleton gets attr_setting and configurations
|
|
255
|
+
# => including modules and classes get attr_setting and configurations
|
|
256
|
+
# => instances of including classes get configurations
|
|
257
|
+
# => extending modules and classes get attr_setting and configurations
|
|
258
|
+
# => instances of extending classes get nothing
|
|
259
|
+
module ::CascadingConfiguration::Hash::ClassConfigurationMockModuleExtended
|
|
260
|
+
extend CascadingConfiguration::Hash
|
|
261
|
+
# => singleton gets attr_setting and configurations
|
|
262
|
+
respond_to?( :attr_module_configuration_hash ).should == true
|
|
263
|
+
respond_to?( :attr_module_hash ).should == true
|
|
264
|
+
method( :attr_module_hash ).should == method( :attr_class_hash )
|
|
265
|
+
attr_module_hash :configuration_setting
|
|
266
|
+
respond_to?( :configuration_setting ).should == true
|
|
267
|
+
configuration_setting.should == {}
|
|
268
|
+
self.configuration_setting[ :a_configuration ] = :some_value
|
|
269
|
+
configuration_setting.should == { :a_configuration => :some_value }
|
|
270
|
+
method_defined?( :configuration_setting ).should == false
|
|
271
|
+
instance_variables.empty?.should == true
|
|
272
|
+
# => including modules and classes get nothing
|
|
273
|
+
module SubmoduleIncluding
|
|
274
|
+
include CascadingConfiguration::Hash::ClassConfigurationMockModuleExtended
|
|
275
|
+
method_defined?( :configuration_setting ).should == false
|
|
276
|
+
respond_to?( :configuration_setting ).should == false
|
|
277
|
+
instance_variables.empty?.should == true
|
|
278
|
+
end
|
|
279
|
+
# => extending modules and classes get nothing
|
|
280
|
+
module SubmoduleExtending
|
|
281
|
+
extend CascadingConfiguration::Hash::ClassConfigurationMockModuleExtended
|
|
282
|
+
method_defined?( :configuration_setting ).should == false
|
|
283
|
+
respond_to?( :configuration_setting ).should == false
|
|
284
|
+
instance_variables.empty?.should == true
|
|
285
|
+
end
|
|
286
|
+
# => instances of including and extending classes get nothing
|
|
287
|
+
class ClassIncluding
|
|
288
|
+
include CascadingConfiguration::Hash::ClassConfigurationMockModuleExtended
|
|
289
|
+
method_defined?( :configuration_setting ).should == false
|
|
290
|
+
respond_to?( :configuration_setting ).should == false
|
|
291
|
+
instance_variables.empty?.should == true
|
|
292
|
+
end
|
|
293
|
+
class ClassExtending
|
|
294
|
+
extend CascadingConfiguration::Hash::ClassConfigurationMockModuleExtended
|
|
295
|
+
method_defined?( :configuration_setting ).should == false
|
|
296
|
+
respond_to?( :configuration_setting ).should == false
|
|
297
|
+
instance_variables.empty?.should == true
|
|
298
|
+
end
|
|
299
|
+
end
|
|
300
|
+
|
|
301
|
+
# * module included with setting
|
|
302
|
+
module ::CascadingConfiguration::Hash::ClassConfigurationMockModuleIncluded
|
|
303
|
+
include CascadingConfiguration::Hash
|
|
304
|
+
# => singleton gets attr_setting and configurations
|
|
305
|
+
respond_to?( :attr_module_hash ).should == true
|
|
306
|
+
attr_module_hash :configuration_setting
|
|
307
|
+
respond_to?( :configuration_setting ).should == true
|
|
308
|
+
configuration_setting.should == {}
|
|
309
|
+
self.configuration_setting[ :a_configuration ] = :some_value
|
|
310
|
+
configuration_setting.should == { :a_configuration => :some_value }
|
|
311
|
+
method_defined?( :configuration_setting ).should == false
|
|
312
|
+
instance_variables.empty?.should == true
|
|
313
|
+
# => including modules and classes get attr_setting and configurations
|
|
314
|
+
module SubmoduleIncluding
|
|
315
|
+
include CascadingConfiguration::Hash::ClassConfigurationMockModuleIncluded
|
|
316
|
+
method_defined?( :configuration_setting ).should == false
|
|
317
|
+
respond_to?( :configuration_setting ).should == true
|
|
318
|
+
configuration_setting.should == { :a_configuration => :some_value }
|
|
319
|
+
configuration_setting[ :other_setting ] = :some_value
|
|
320
|
+
configuration_setting.should == { :a_configuration => :some_value,
|
|
321
|
+
:other_setting => :some_value }
|
|
322
|
+
configuration_setting.delete( :other_setting ).should == :some_value
|
|
323
|
+
configuration_setting.should == { :a_configuration => :some_value }
|
|
324
|
+
instance_variables.empty?.should == true
|
|
325
|
+
end
|
|
326
|
+
# => extending modules and classes get attr_setting and configurations
|
|
327
|
+
module SubmoduleExtending
|
|
328
|
+
extend CascadingConfiguration::Hash::ClassConfigurationMockModuleIncluded
|
|
329
|
+
# if we're extended then we want to use the eigenclass ancestor chain
|
|
330
|
+
# - the first ancestor will be the extending module
|
|
331
|
+
# - the rest of the ancestors will be the extending module's include chain
|
|
332
|
+
respond_to?( :configuration_setting ).should == false
|
|
333
|
+
method_defined?( :configuration_setting ).should == false
|
|
334
|
+
instance_variables.empty?.should == true
|
|
335
|
+
end
|
|
336
|
+
# => instances of including classes get configurations
|
|
337
|
+
class ClassIncluding
|
|
338
|
+
include CascadingConfiguration::Hash::ClassConfigurationMockModuleIncluded
|
|
339
|
+
method_defined?( :configuration_setting ).should == false
|
|
340
|
+
respond_to?( :configuration_setting ).should == true
|
|
341
|
+
configuration_setting.should == { :a_configuration => :some_value }
|
|
342
|
+
configuration_setting[ :other_setting ] = :some_value
|
|
343
|
+
configuration_setting.should == { :a_configuration => :some_value,
|
|
344
|
+
:other_setting => :some_value }
|
|
345
|
+
configuration_setting.delete( :other_setting ).should == :some_value
|
|
346
|
+
configuration_setting.should == { :a_configuration => :some_value }
|
|
347
|
+
instance_variables.empty?.should == true
|
|
348
|
+
end
|
|
349
|
+
setting_class_including_instance = ClassIncluding.new
|
|
350
|
+
setting_class_including_instance.respond_to?( :configuration_setting ).should == false
|
|
351
|
+
setting_class_including_instance.instance_variables.empty?.should == true
|
|
352
|
+
class ClassExtending
|
|
353
|
+
extend CascadingConfiguration::Hash::ClassConfigurationMockModuleIncluded
|
|
354
|
+
respond_to?( :configuration_setting ).should == false
|
|
355
|
+
method_defined?( :configuration_setting ).should == false
|
|
356
|
+
instance_variables.empty?.should == true
|
|
357
|
+
end
|
|
358
|
+
setting_class_including_instance = ClassExtending.new
|
|
359
|
+
setting_class_including_instance.respond_to?( :configuration_setting ).should == false
|
|
360
|
+
setting_class_including_instance.instance_variables.empty?.should == true
|
|
361
|
+
end
|
|
362
|
+
|
|
363
|
+
class CascadingConfiguration::Hash::ClassConfigurationMockClass
|
|
364
|
+
include CascadingConfiguration::Hash::ClassConfigurationMockModuleIncluded::SubmoduleIncluding
|
|
365
|
+
respond_to?( :configuration_setting ).should == true
|
|
366
|
+
method_defined?( :configuration_setting ).should == false
|
|
367
|
+
configuration_setting.should == { :a_configuration => :some_value }
|
|
368
|
+
configuration_setting[ :other_setting ] = :some_value
|
|
369
|
+
configuration_setting.should == { :a_configuration => :some_value,
|
|
370
|
+
:other_setting => :some_value }
|
|
371
|
+
configuration_setting.delete( :other_setting ).should == :some_value
|
|
372
|
+
configuration_setting.should == { :a_configuration => :some_value }
|
|
373
|
+
instance_variables.empty?.should == true
|
|
374
|
+
end
|
|
375
|
+
|
|
376
|
+
object_instance_one = CascadingConfiguration::Hash::ClassConfigurationMockClass.new
|
|
377
|
+
object_instance_one.respond_to?( :configuration_setting ).should == false
|
|
378
|
+
object_instance_one.instance_variables.empty?.should == true
|
|
379
|
+
|
|
380
|
+
class CascadingConfiguration::Hash::ClassConfigurationMockClassSub1 < CascadingConfiguration::Hash::ClassConfigurationMockClass
|
|
381
|
+
respond_to?( :configuration_setting ).should == true
|
|
382
|
+
method_defined?( :configuration_setting ).should == false
|
|
383
|
+
configuration_setting.should == { :a_configuration => :some_value }
|
|
384
|
+
self.configuration_setting[ :another_configuration ] = :some_value
|
|
385
|
+
configuration_setting.should == { :a_configuration => :some_value,
|
|
386
|
+
:another_configuration => :some_value }
|
|
387
|
+
instance_variables.empty?.should == true
|
|
388
|
+
end
|
|
389
|
+
|
|
390
|
+
object_instance_two = CascadingConfiguration::Hash::ClassConfigurationMockClassSub1.new
|
|
391
|
+
object_instance_two.respond_to?( :configuration_setting ).should == false
|
|
392
|
+
|
|
393
|
+
# change ancestor setting
|
|
394
|
+
CascadingConfiguration::Hash::ClassConfigurationMockClass.configuration_setting[ :a_yet_unused_configuration ] = :some_value
|
|
395
|
+
CascadingConfiguration::Hash::ClassConfigurationMockClass.configuration_setting.should == { :a_configuration => :some_value,
|
|
396
|
+
:a_yet_unused_configuration => :some_value }
|
|
397
|
+
CascadingConfiguration::Hash::ClassConfigurationMockClassSub1.configuration_setting.should == { :a_configuration => :some_value,
|
|
398
|
+
:a_yet_unused_configuration => :some_value,
|
|
399
|
+
:another_configuration => :some_value }
|
|
400
|
+
|
|
401
|
+
# freeze ancestor setting
|
|
402
|
+
CascadingConfiguration::Hash::ClassConfigurationMockClassSub1.configuration_setting.freeze!
|
|
403
|
+
CascadingConfiguration::Hash::ClassConfigurationMockClassSub1.configuration_setting.should == { :a_configuration => :some_value,
|
|
404
|
+
:a_yet_unused_configuration => :some_value,
|
|
405
|
+
:another_configuration => :some_value }
|
|
406
|
+
CascadingConfiguration::Hash::ClassConfigurationMockClass.configuration_setting[ :non_cascading_configuration ] = :some_value
|
|
407
|
+
CascadingConfiguration::Hash::ClassConfigurationMockClass.configuration_setting.should == { :a_configuration => :some_value,
|
|
408
|
+
:a_yet_unused_configuration => :some_value,
|
|
409
|
+
:non_cascading_configuration => :some_value }
|
|
410
|
+
CascadingConfiguration::Hash::ClassConfigurationMockClassSub1.configuration_setting.should == { :a_configuration => :some_value,
|
|
411
|
+
:a_yet_unused_configuration => :some_value,
|
|
412
|
+
:another_configuration => :some_value }
|
|
413
|
+
|
|
414
|
+
module ::CascadingConfiguration::Hash::ClassConfigurationMockModule
|
|
415
|
+
include CascadingConfiguration::Hash
|
|
416
|
+
attr_hash :some_hash do
|
|
417
|
+
def merge!( other_hash )
|
|
418
|
+
other_hash.each do |key, foreign_value|
|
|
419
|
+
if existing_value = self[ key ]
|
|
420
|
+
self[ key ] = foreign_value - existing_value
|
|
421
|
+
else
|
|
422
|
+
self[ key ] = foreign_value
|
|
423
|
+
end
|
|
424
|
+
end
|
|
425
|
+
end
|
|
426
|
+
end
|
|
427
|
+
self.some_hash = { :one => 1, :two => 2 }
|
|
428
|
+
self.some_hash.should == { :one => 1, :two => 2 }
|
|
429
|
+
end
|
|
430
|
+
|
|
431
|
+
module ::CascadingConfiguration::Hash::ClassConfigurationMockModule2
|
|
432
|
+
include CascadingConfiguration::Hash::ClassConfigurationMockModule
|
|
433
|
+
self.some_hash.should == { :one => 1, :two => 2 }
|
|
434
|
+
self.some_hash.merge!( { :one => 1, :two => 2 } )
|
|
435
|
+
self.some_hash.should == { :one => 0, :two => 0 }
|
|
436
|
+
end
|
|
437
|
+
|
|
438
|
+
end
|
|
439
|
+
|
|
440
|
+
#####################
|
|
441
|
+
# attr_local_hash #
|
|
442
|
+
#####################
|
|
443
|
+
|
|
444
|
+
it 'can define a local configuration hash, which will not cascade' do
|
|
445
|
+
|
|
446
|
+
# possibilities:
|
|
447
|
+
# * module extended with setting
|
|
448
|
+
# => singleton gets attr_setting and configurations
|
|
449
|
+
# => including modules and classes get nothing
|
|
450
|
+
# => extending modules and classes get nothing
|
|
451
|
+
# => instances of including and extending classes get nothing
|
|
452
|
+
# * module included with setting
|
|
453
|
+
# => singleton gets attr_setting and configurations
|
|
454
|
+
# => including modules and classes get attr_setting and configurations
|
|
455
|
+
# => instances of including classes get configurations
|
|
456
|
+
# => extending modules and classes get attr_setting and configurations
|
|
457
|
+
# => instances of extending classes get nothing
|
|
458
|
+
module ::CascadingConfiguration::Hash::LocalConfigurationMockModuleExtended
|
|
459
|
+
extend CascadingConfiguration::Hash
|
|
460
|
+
# => singleton gets attr_setting and configurations
|
|
461
|
+
respond_to?( :attr_local_configuration_hash ).should == true
|
|
462
|
+
respond_to?( :attr_local_hash ).should == true
|
|
463
|
+
attr_local_hash :configuration_setting
|
|
464
|
+
respond_to?( :configuration_setting ).should == true
|
|
465
|
+
configuration_setting.should == {}
|
|
466
|
+
self.configuration_setting[ :a_configuration ] = :some_value
|
|
467
|
+
configuration_setting.should == { :a_configuration => :some_value }
|
|
468
|
+
method_defined?( :configuration_setting ).should == false
|
|
469
|
+
instance_variables.empty?.should == true
|
|
470
|
+
# => including modules and classes get nothing
|
|
471
|
+
module SubmoduleIncluding
|
|
472
|
+
include CascadingConfiguration::Hash::LocalConfigurationMockModuleExtended
|
|
473
|
+
method_defined?( :configuration_setting ).should == false
|
|
474
|
+
respond_to?( :configuration_setting ).should == false
|
|
475
|
+
instance_variables.empty?.should == true
|
|
476
|
+
end
|
|
477
|
+
# => extending modules and classes get nothing
|
|
478
|
+
module SubmoduleExtending
|
|
479
|
+
extend CascadingConfiguration::Hash::LocalConfigurationMockModuleExtended
|
|
480
|
+
method_defined?( :configuration_setting ).should == false
|
|
481
|
+
respond_to?( :configuration_setting ).should == false
|
|
482
|
+
instance_variables.empty?.should == true
|
|
483
|
+
end
|
|
484
|
+
# => instances of including and extending classes get nothing
|
|
485
|
+
class ClassIncluding
|
|
486
|
+
include CascadingConfiguration::Hash::LocalConfigurationMockModuleExtended
|
|
487
|
+
method_defined?( :configuration_setting ).should == false
|
|
488
|
+
respond_to?( :configuration_setting ).should == false
|
|
489
|
+
instance_variables.empty?.should == true
|
|
490
|
+
end
|
|
491
|
+
class ClassExtending
|
|
492
|
+
extend CascadingConfiguration::Hash::LocalConfigurationMockModuleExtended
|
|
493
|
+
method_defined?( :configuration_setting ).should == false
|
|
494
|
+
respond_to?( :configuration_setting ).should == false
|
|
495
|
+
instance_variables.empty?.should == true
|
|
496
|
+
end
|
|
497
|
+
end
|
|
498
|
+
|
|
499
|
+
# * module included with setting
|
|
500
|
+
module ::CascadingConfiguration::Hash::LocalConfigurationMockModuleIncluded
|
|
501
|
+
include CascadingConfiguration::Hash
|
|
502
|
+
# => singleton gets attr_setting and configurations
|
|
503
|
+
respond_to?( :attr_local_hash ).should == true
|
|
504
|
+
attr_local_hash :configuration_setting
|
|
505
|
+
respond_to?( :configuration_setting ).should == true
|
|
506
|
+
configuration_setting.should == {}
|
|
507
|
+
self.configuration_setting[ :a_configuration ] = :some_value
|
|
508
|
+
configuration_setting.should == { :a_configuration => :some_value }
|
|
509
|
+
method_defined?( :configuration_setting ).should == true
|
|
510
|
+
instance_variables.empty?.should == true
|
|
511
|
+
# => including modules and classes get attr_setting and configurations
|
|
512
|
+
module SubmoduleIncluding
|
|
513
|
+
include CascadingConfiguration::Hash::LocalConfigurationMockModuleIncluded
|
|
514
|
+
method_defined?( :configuration_setting ).should == true
|
|
515
|
+
respond_to?( :configuration_setting ).should == false
|
|
516
|
+
instance_variables.empty?.should == true
|
|
517
|
+
end
|
|
518
|
+
# => extending modules and classes get attr_setting and configurations
|
|
519
|
+
module SubmoduleExtending
|
|
520
|
+
extend CascadingConfiguration::Hash::LocalConfigurationMockModuleIncluded
|
|
521
|
+
# if we're extended then we want to use the eigenclass ancestor chain
|
|
522
|
+
# - the first ancestor will be the extending module
|
|
523
|
+
# - the rest of the ancestors will be the extending module's include chain
|
|
524
|
+
method_defined?( :configuration_setting ).should == false
|
|
525
|
+
respond_to?( :configuration_setting ).should == true
|
|
526
|
+
instance_variables.empty?.should == true
|
|
527
|
+
end
|
|
528
|
+
# => instances of including classes get configurations
|
|
529
|
+
class ClassIncluding
|
|
530
|
+
include CascadingConfiguration::Hash::LocalConfigurationMockModuleIncluded
|
|
531
|
+
method_defined?( :configuration_setting ).should == true
|
|
532
|
+
respond_to?( :configuration_setting ).should == false
|
|
533
|
+
instance_variables.empty?.should == true
|
|
534
|
+
end
|
|
535
|
+
setting_class_including_instance = ClassIncluding.new
|
|
536
|
+
setting_class_including_instance.respond_to?( :configuration_setting ).should == true
|
|
537
|
+
setting_class_including_instance.instance_variables.empty?.should == true
|
|
538
|
+
class ClassExtending
|
|
539
|
+
extend CascadingConfiguration::Hash::LocalConfigurationMockModuleIncluded
|
|
540
|
+
method_defined?( :configuration_setting ).should == false
|
|
541
|
+
respond_to?( :configuration_setting ).should == true
|
|
542
|
+
instance_variables.empty?.should == true
|
|
543
|
+
end
|
|
544
|
+
setting_class_including_instance = ClassExtending.new
|
|
545
|
+
setting_class_including_instance.respond_to?( :configuration_setting ).should == false
|
|
546
|
+
setting_class_including_instance.instance_variables.empty?.should == true
|
|
547
|
+
end
|
|
548
|
+
|
|
549
|
+
class CascadingConfiguration::Hash::LocalConfigurationMockClass
|
|
550
|
+
include CascadingConfiguration::Hash::LocalConfigurationMockModuleIncluded::SubmoduleIncluding
|
|
551
|
+
method_defined?( :configuration_setting ).should == true
|
|
552
|
+
respond_to?( :configuration_setting ).should == false
|
|
553
|
+
instance_variables.empty?.should == true
|
|
554
|
+
end
|
|
555
|
+
|
|
556
|
+
object_instance_one = CascadingConfiguration::Hash::LocalConfigurationMockClass.new
|
|
557
|
+
object_instance_one.respond_to?( :configuration_setting ).should == true
|
|
558
|
+
object_instance_one.instance_variables.empty?.should == true
|
|
559
|
+
|
|
560
|
+
class CascadingConfiguration::Hash::LocalConfigurationMockClassSub1 < CascadingConfiguration::Hash::LocalConfigurationMockClass
|
|
561
|
+
method_defined?( :configuration_setting ).should == true
|
|
562
|
+
respond_to?( :configuration_setting ).should == false
|
|
563
|
+
instance_variables.empty?.should == true
|
|
564
|
+
end
|
|
565
|
+
|
|
566
|
+
object_instance_two = CascadingConfiguration::Hash::LocalConfigurationMockClassSub1.new
|
|
567
|
+
object_instance_two.respond_to?( :configuration_setting ).should == true
|
|
568
|
+
object_instance_two.instance_variables.empty?.should == true
|
|
569
|
+
|
|
570
|
+
end
|
|
571
|
+
|
|
572
|
+
########################
|
|
573
|
+
# attr_instance_hash #
|
|
574
|
+
########################
|
|
575
|
+
|
|
576
|
+
it 'can define a local configuration hash, which will not cascade' do
|
|
577
|
+
|
|
578
|
+
# possibilities:
|
|
579
|
+
# * module extended with setting
|
|
580
|
+
# => singleton gets attr_setting and configurations
|
|
581
|
+
# => including modules and classes get nothing
|
|
582
|
+
# => extending modules and classes get nothing
|
|
583
|
+
# => instances of including and extending classes get nothing
|
|
584
|
+
# * module included with setting
|
|
585
|
+
# => singleton gets attr_setting and configurations
|
|
586
|
+
# => including modules and classes get attr_setting and configurations
|
|
587
|
+
# => instances of including classes get configurations
|
|
588
|
+
# => extending modules and classes get attr_setting and configurations
|
|
589
|
+
# => instances of extending classes get nothing
|
|
590
|
+
module ::CascadingConfiguration::Hash::InstanceConfigurationMockModuleExtended
|
|
591
|
+
extend CascadingConfiguration::Hash
|
|
592
|
+
# => singleton gets attr_setting and configurations
|
|
593
|
+
method_defined?( :configuration_setting ).should == false
|
|
594
|
+
instance_variables.empty?.should == true
|
|
595
|
+
# => including modules and classes get nothing
|
|
596
|
+
module SubmoduleIncluding
|
|
597
|
+
include CascadingConfiguration::Hash::InstanceConfigurationMockModuleExtended
|
|
598
|
+
method_defined?( :configuration_setting ).should == false
|
|
599
|
+
respond_to?( :configuration_setting ).should == false
|
|
600
|
+
instance_variables.empty?.should == true
|
|
601
|
+
end
|
|
602
|
+
# => extending modules and classes get nothing
|
|
603
|
+
module SubmoduleExtending
|
|
604
|
+
extend CascadingConfiguration::Hash::InstanceConfigurationMockModuleExtended
|
|
605
|
+
method_defined?( :configuration_setting ).should == false
|
|
606
|
+
respond_to?( :configuration_setting ).should == false
|
|
607
|
+
instance_variables.empty?.should == true
|
|
608
|
+
end
|
|
609
|
+
# => instances of including and extending classes get nothing
|
|
610
|
+
class ClassIncluding
|
|
611
|
+
include CascadingConfiguration::Hash::InstanceConfigurationMockModuleExtended
|
|
612
|
+
method_defined?( :configuration_setting ).should == false
|
|
613
|
+
respond_to?( :configuration_setting ).should == false
|
|
614
|
+
instance_variables.empty?.should == true
|
|
615
|
+
end
|
|
616
|
+
class ClassExtending
|
|
617
|
+
extend CascadingConfiguration::Hash::InstanceConfigurationMockModuleExtended
|
|
618
|
+
method_defined?( :configuration_setting ).should == false
|
|
619
|
+
respond_to?( :configuration_setting ).should == false
|
|
620
|
+
instance_variables.empty?.should == true
|
|
621
|
+
end
|
|
622
|
+
end
|
|
623
|
+
|
|
624
|
+
# * module included with setting
|
|
625
|
+
module ::CascadingConfiguration::Hash::InstanceConfigurationMockModuleIncluded
|
|
626
|
+
include CascadingConfiguration::Hash
|
|
627
|
+
# => singleton gets attr_setting and configurations
|
|
628
|
+
respond_to?( :attr_instance_hash ).should == true
|
|
629
|
+
attr_instance_hash :configuration_setting
|
|
630
|
+
respond_to?( :configuration_setting ).should == false
|
|
631
|
+
method_defined?( :configuration_setting ).should == true
|
|
632
|
+
instance_variables.empty?.should == true
|
|
633
|
+
# => including modules and classes get attr_setting and configurations
|
|
634
|
+
module SubmoduleIncluding
|
|
635
|
+
include CascadingConfiguration::Hash::InstanceConfigurationMockModuleIncluded
|
|
636
|
+
method_defined?( :configuration_setting ).should == true
|
|
637
|
+
respond_to?( :configuration_setting ).should == false
|
|
638
|
+
instance_variables.empty?.should == true
|
|
639
|
+
end
|
|
640
|
+
# => extending modules and classes get attr_setting and configurations
|
|
641
|
+
module SubmoduleExtending
|
|
642
|
+
extend CascadingConfiguration::Hash::InstanceConfigurationMockModuleIncluded
|
|
643
|
+
# if we're extended then we want to use the eigenclass ancestor chain
|
|
644
|
+
# - the first ancestor will be the extending module
|
|
645
|
+
# - the rest of the ancestors will be the extending module's include chain
|
|
646
|
+
method_defined?( :configuration_setting ).should == false
|
|
647
|
+
respond_to?( :configuration_setting ).should == true
|
|
648
|
+
instance_variables.empty?.should == true
|
|
649
|
+
end
|
|
650
|
+
# => instances of including classes get configurations
|
|
651
|
+
class ClassIncluding
|
|
652
|
+
include CascadingConfiguration::Hash::InstanceConfigurationMockModuleIncluded
|
|
653
|
+
method_defined?( :configuration_setting ).should == true
|
|
654
|
+
respond_to?( :configuration_setting ).should == false
|
|
655
|
+
instance_variables.empty?.should == true
|
|
656
|
+
end
|
|
657
|
+
setting_class_including_instance = ClassIncluding.new
|
|
658
|
+
setting_class_including_instance.respond_to?( :configuration_setting ).should == true
|
|
659
|
+
setting_class_including_instance.instance_variables.empty?.should == true
|
|
660
|
+
class ClassExtending
|
|
661
|
+
extend CascadingConfiguration::Hash::InstanceConfigurationMockModuleIncluded
|
|
662
|
+
method_defined?( :configuration_setting ).should == false
|
|
663
|
+
respond_to?( :configuration_setting ).should == true
|
|
664
|
+
instance_variables.empty?.should == true
|
|
665
|
+
end
|
|
666
|
+
setting_class_including_instance = ClassExtending.new
|
|
667
|
+
setting_class_including_instance.respond_to?( :configuration_setting ).should == false
|
|
668
|
+
setting_class_including_instance.instance_variables.empty?.should == true
|
|
669
|
+
end
|
|
670
|
+
|
|
671
|
+
class CascadingConfiguration::Hash::InstanceConfigurationMockClass
|
|
672
|
+
include CascadingConfiguration::Hash::InstanceConfigurationMockModuleIncluded::SubmoduleIncluding
|
|
673
|
+
method_defined?( :configuration_setting ).should == true
|
|
674
|
+
respond_to?( :configuration_setting ).should == false
|
|
675
|
+
instance_variables.empty?.should == true
|
|
676
|
+
end
|
|
677
|
+
|
|
678
|
+
object_instance_one = CascadingConfiguration::Hash::InstanceConfigurationMockClass.new
|
|
679
|
+
object_instance_one.respond_to?( :configuration_setting ).should == true
|
|
680
|
+
object_instance_one.instance_variables.empty?.should == true
|
|
681
|
+
|
|
682
|
+
class CascadingConfiguration::Hash::InstanceConfigurationMockClassSub1 < CascadingConfiguration::Hash::InstanceConfigurationMockClass
|
|
683
|
+
method_defined?( :configuration_setting ).should == true
|
|
684
|
+
respond_to?( :configuration_setting ).should == false
|
|
685
|
+
instance_variables.empty?.should == true
|
|
686
|
+
end
|
|
687
|
+
|
|
688
|
+
object_instance_two = CascadingConfiguration::Hash::InstanceConfigurationMockClassSub1.new
|
|
689
|
+
object_instance_two.respond_to?( :configuration_setting ).should == true
|
|
690
|
+
object_instance_two.instance_variables.empty?.should == true
|
|
691
|
+
|
|
692
|
+
end
|
|
693
|
+
|
|
694
|
+
######################
|
|
695
|
+
# attr_object_hash #
|
|
696
|
+
######################
|
|
697
|
+
|
|
698
|
+
it 'can define a local configuration hash, which will not cascade' do
|
|
699
|
+
|
|
700
|
+
# possibilities:
|
|
701
|
+
# * module extended with setting
|
|
702
|
+
# => singleton gets attr_setting and configurations
|
|
703
|
+
# => including modules and classes get nothing
|
|
704
|
+
# => extending modules and classes get nothing
|
|
705
|
+
# => instances of including and extending classes get nothing
|
|
706
|
+
# * module included with setting
|
|
707
|
+
# => singleton gets attr_setting and configurations
|
|
708
|
+
# => including modules and classes get attr_setting and configurations
|
|
709
|
+
# => instances of including classes get configurations
|
|
710
|
+
# => extending modules and classes get attr_setting and configurations
|
|
711
|
+
# => instances of extending classes get nothing
|
|
712
|
+
module ::CascadingConfiguration::Hash::ObjectConfigurationMockModuleExtended
|
|
713
|
+
extend CascadingConfiguration::Hash
|
|
714
|
+
# => singleton gets attr_setting and configurations
|
|
715
|
+
respond_to?( :attr_object_configuration_hash ).should == true
|
|
716
|
+
respond_to?( :attr_object_hash ).should == true
|
|
717
|
+
attr_object_hash :configuration_setting
|
|
718
|
+
respond_to?( :configuration_setting ).should == true
|
|
719
|
+
configuration_setting.should == {}
|
|
720
|
+
self.configuration_setting[ :a_configuration ] = :some_value
|
|
721
|
+
configuration_setting.should == { :a_configuration => :some_value }
|
|
722
|
+
method_defined?( :configuration_setting ).should == false
|
|
723
|
+
instance_variables.empty?.should == true
|
|
724
|
+
# => including modules and classes get nothing
|
|
725
|
+
module SubmoduleIncluding
|
|
726
|
+
include CascadingConfiguration::Hash::ObjectConfigurationMockModuleExtended
|
|
727
|
+
method_defined?( :configuration_setting ).should == false
|
|
728
|
+
respond_to?( :configuration_setting ).should == false
|
|
729
|
+
instance_variables.empty?.should == true
|
|
730
|
+
end
|
|
731
|
+
# => extending modules and classes get nothing
|
|
732
|
+
module SubmoduleExtending
|
|
733
|
+
extend CascadingConfiguration::Hash::ObjectConfigurationMockModuleExtended
|
|
734
|
+
method_defined?( :configuration_setting ).should == false
|
|
735
|
+
respond_to?( :configuration_setting ).should == false
|
|
736
|
+
instance_variables.empty?.should == true
|
|
737
|
+
end
|
|
738
|
+
# => instances of including and extending classes get nothing
|
|
739
|
+
class ClassIncluding
|
|
740
|
+
include CascadingConfiguration::Hash::ObjectConfigurationMockModuleExtended
|
|
741
|
+
method_defined?( :configuration_setting ).should == false
|
|
742
|
+
respond_to?( :configuration_setting ).should == false
|
|
743
|
+
instance_variables.empty?.should == true
|
|
744
|
+
end
|
|
745
|
+
class ClassExtending
|
|
746
|
+
extend CascadingConfiguration::Hash::ObjectConfigurationMockModuleExtended
|
|
747
|
+
method_defined?( :configuration_setting ).should == false
|
|
748
|
+
respond_to?( :configuration_setting ).should == false
|
|
749
|
+
instance_variables.empty?.should == true
|
|
750
|
+
end
|
|
751
|
+
end
|
|
752
|
+
|
|
753
|
+
# * module included with setting
|
|
754
|
+
module ::CascadingConfiguration::Hash::ObjectConfigurationMockModuleIncluded
|
|
755
|
+
include CascadingConfiguration::Hash
|
|
756
|
+
# => singleton gets attr_setting and configurations
|
|
757
|
+
respond_to?( :attr_object_hash ).should == true
|
|
758
|
+
attr_object_hash :configuration_setting
|
|
759
|
+
respond_to?( :configuration_setting ).should == true
|
|
760
|
+
configuration_setting.should == {}
|
|
761
|
+
self.configuration_setting[ :a_configuration ] = :some_value
|
|
762
|
+
configuration_setting.should == { :a_configuration => :some_value }
|
|
763
|
+
method_defined?( :configuration_setting ).should == false
|
|
764
|
+
instance_variables.empty?.should == true
|
|
765
|
+
# => including modules and classes get attr_setting and configurations
|
|
766
|
+
module SubmoduleIncluding
|
|
767
|
+
include CascadingConfiguration::Hash::ObjectConfigurationMockModuleIncluded
|
|
768
|
+
method_defined?( :configuration_setting ).should == false
|
|
769
|
+
respond_to?( :configuration_setting ).should == false
|
|
770
|
+
instance_variables.empty?.should == true
|
|
771
|
+
end
|
|
772
|
+
# => extending modules and classes get attr_setting and configurations
|
|
773
|
+
module SubmoduleExtending
|
|
774
|
+
extend CascadingConfiguration::Hash::ObjectConfigurationMockModuleIncluded
|
|
775
|
+
# if we're extended then we want to use the eigenclass ancestor chain
|
|
776
|
+
# - the first ancestor will be the extending module
|
|
777
|
+
# - the rest of the ancestors will be the extending module's include chain
|
|
778
|
+
method_defined?( :configuration_setting ).should == false
|
|
779
|
+
respond_to?( :configuration_setting ).should == false
|
|
780
|
+
instance_variables.empty?.should == true
|
|
781
|
+
end
|
|
782
|
+
# => instances of including classes get configurations
|
|
783
|
+
class ClassIncluding
|
|
784
|
+
include CascadingConfiguration::Hash::ObjectConfigurationMockModuleIncluded
|
|
785
|
+
method_defined?( :configuration_setting ).should == false
|
|
786
|
+
respond_to?( :configuration_setting ).should == false
|
|
787
|
+
instance_variables.empty?.should == true
|
|
788
|
+
end
|
|
789
|
+
setting_class_including_instance = ClassIncluding.new
|
|
790
|
+
setting_class_including_instance.respond_to?( :configuration_setting ).should == false
|
|
791
|
+
setting_class_including_instance.instance_variables.empty?.should == true
|
|
792
|
+
class ClassExtending
|
|
793
|
+
extend CascadingConfiguration::Hash::ObjectConfigurationMockModuleIncluded
|
|
794
|
+
method_defined?( :configuration_setting ).should == false
|
|
795
|
+
respond_to?( :configuration_setting ).should == false
|
|
796
|
+
instance_variables.empty?.should == true
|
|
797
|
+
end
|
|
798
|
+
setting_class_including_instance = ClassExtending.new
|
|
799
|
+
setting_class_including_instance.respond_to?( :configuration_setting ).should == false
|
|
800
|
+
setting_class_including_instance.instance_variables.empty?.should == true
|
|
801
|
+
end
|
|
802
|
+
|
|
803
|
+
class CascadingConfiguration::Hash::ObjectConfigurationMockClass
|
|
804
|
+
include CascadingConfiguration::Hash::ObjectConfigurationMockModuleIncluded::SubmoduleIncluding
|
|
805
|
+
method_defined?( :configuration_setting ).should == false
|
|
806
|
+
respond_to?( :configuration_setting ).should == false
|
|
807
|
+
instance_variables.empty?.should == true
|
|
808
|
+
end
|
|
809
|
+
|
|
810
|
+
object_instance_one = CascadingConfiguration::Hash::ObjectConfigurationMockClass.new
|
|
811
|
+
object_instance_one.respond_to?( :configuration_setting ).should == false
|
|
812
|
+
object_instance_one.instance_variables.empty?.should == true
|
|
813
|
+
|
|
814
|
+
class CascadingConfiguration::Hash::ObjectConfigurationMockClassSub1 < CascadingConfiguration::Hash::ObjectConfigurationMockClass
|
|
815
|
+
method_defined?( :configuration_setting ).should == false
|
|
816
|
+
respond_to?( :configuration_setting ).should == false
|
|
817
|
+
instance_variables.empty?.should == true
|
|
818
|
+
end
|
|
819
|
+
|
|
820
|
+
object_instance_two = CascadingConfiguration::Hash::ObjectConfigurationMockClassSub1.new
|
|
821
|
+
object_instance_two.respond_to?( :configuration_setting ).should == false
|
|
822
|
+
object_instance_two.instance_variables.empty?.should == true
|
|
823
|
+
|
|
824
|
+
end
|
|
825
|
+
|
|
826
|
+
end
|