1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
|
module Test
module Unit
module Attribute
class << self
def included(base)
base.extend(BaseClassMethods)
base.extend(ClassMethods)
end
end
module BaseClassMethods
def attributes_table
{}
end
end
module ClassMethods
def method_added(name)
super
return unless defined?(@current_attributes)
attributes = {}
kept_attributes = {}
@current_attributes.each do |attribute_name, attribute|
attributes[attribute_name] = attribute[:value]
kept_attributes[attribute_name] = attribute if attribute[:keep]
end
set_attributes(name, attributes)
@current_attributes = kept_attributes
end
def attribute(name, value, options={}, *method_names)
unless options.is_a?(Hash)
method_names << options
options = {}
end
@current_attributes ||= {}
if method_names.empty?
@current_attributes[name] = options.merge(:value => value)
else
method_names.each do |method_name|
set_attributes(method_name, {name => value})
end
end
end
def attributes_table
@attributes_table ||= {}
super.merge(@attributes_table)
end
def set_attributes(method_name, new_attributes)
return if new_attributes.empty?
method_name = normalize_method_name(method_name)
@attributes_table ||= {}
@attributes_table[method_name] ||= {}
current_attributes = @attributes_table[method_name]
new_attributes.each do |key, value|
key = normalize_attribute_name(key)
observers = attribute_observers(key) || []
observers.each do |observer|
observer.call(self,
key,
(attributes(method_name) || {})[key],
value,
method_name)
end
current_attributes[key] = value
end
end
def attributes(method_name)
method_name = normalize_method_name(method_name)
attributes = attributes_table[method_name]
ancestors[1..-1].each do |ancestor|
if ancestor.is_a?(Class) and ancestor < Test::Unit::Attribute
parent_attributes = ancestor.attributes(method_name)
if attributes
attributes = (parent_attributes || {}).merge(attributes)
else
attributes = parent_attributes
end
break
end
end
attributes
end
def get_attribute(method_name, attribute_name)
attribute_name = normalize_attribute_name(attribute_name)
(attributes(method_name) || {})[attribute_name]
end
@@attribute_observers = {}
def register_attribute_observer(attribute_name, observer=Proc.new)
attribute_name = normalize_attribute_name(attribute_name)
@@attribute_observers[attribute_name] ||= []
@@attribute_observers[attribute_name] << observer
end
def attribute_observers(attribute_name)
attribute_name = normalize_attribute_name(attribute_name)
@@attribute_observers[attribute_name]
end
private
def normalize_attribute_name(name)
name.to_s
end
def normalize_method_name(name)
name.to_s
end
end
def attributes
self.class.attributes(@method_name) || {}
end
def [](name)
self.class.get_attribute(@method_name, name)
end
end
end
end
|
