Module: Test::Unit::Attribute::ClassMethods

Defined in:
lib/test/unit/attribute.rb

Constant Summary collapse

@@attribute_observers = 
{}

Instance Method Summary collapse

Instance Method Details

#attribute(name, value, options = {}, *method_names) ⇒ Object 



32
33
34
35
36
37
38
39
40
41
42
43
44
45
 
# File 'lib/test/unit/attribute.rb', line 32

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

#attribute_observers(attribute_name) ⇒ Object 



101
102
103
104
 
# File 'lib/test/unit/attribute.rb', line 101

def attribute_observers(attribute_name)
  attribute_name = normalize_attribute_name(attribute_name)
  @@attribute_observers[attribute_name]
end

#attributes(method_name) ⇒ Object 



72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
 
# File 'lib/test/unit/attribute.rb', line 72

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

#attributes_table ⇒ Object 



47
48
49
50
 
# File 'lib/test/unit/attribute.rb', line 47

def attributes_table
  @attributes_table ||= {}
  super.merge(@attributes_table)
end

#get_attribute(method_name, attribute_name) ⇒ Object 



89
90
91
92
 
# File 'lib/test/unit/attribute.rb', line 89

def get_attribute(method_name, attribute_name)
  attribute_name = normalize_attribute_name(attribute_name)
  (attributes(method_name) || {})[attribute_name]
end

#method_added(name) ⇒ Object 



18
19
20
21
22
23
24
25
26
27
28
29
30
 
# File 'lib/test/unit/attribute.rb', line 18

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

#register_attribute_observer(attribute_name, observer = Proc.new) ⇒ Object 



95
96
97
98
99
 
# File 'lib/test/unit/attribute.rb', line 95

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

#set_attributes(method_name, new_attributes) ⇒ Object 



52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
 
# File 'lib/test/unit/attribute.rb', line 52

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