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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
|
require 'rdoc/context'
##
# ClassModule is the base class for objects representing either a class or a
# module.
class RDoc::ClassModule < RDoc::Context
MARSHAL_VERSION = 0 # :nodoc:
attr_accessor :diagram
##
# Creates a new ClassModule with +name+ with optional +superclass+
def initialize(name, superclass = 'Object')
@diagram = nil
@full_name = nil
@name = name
@superclass = superclass
super()
end
##
# Ancestors list for this ClassModule (abstract)
def ancestors
raise NotImplementedError
end
##
# Appends +comment+ to the current comment, but separated by a rule. Works
# more like <tt>+=</tt>.
def comment=(comment)
return if comment.empty?
comment = "#{@comment}\n---\n#{normalize_comment comment}" unless
@comment.empty?
super
end
##
# Finds a class or module with +name+ in this namespace or its descendents
def find_class_named(name)
return self if full_name == name
return self if @name == name
@classes.values.find do |klass|
next if klass == self
klass.find_class_named name
end
end
##
# Return the fully qualified name of this class or module
def full_name
@full_name ||= if RDoc::ClassModule === @parent then
"#{@parent.full_name}::#{@name}"
else
@name
end
end
##
# 'module' or 'class'
def type
module? ? 'module' : 'class'
end
def marshal_dump # :nodoc:
attrs = attributes.sort.map do |attr|
[attr.name, attr.rw]
end
method_types = methods_by_type.map do |type, visibilities|
visibilities = visibilities.map do |visibility, methods|
method_names = methods.map do |method|
method.name
end
[visibility, method_names.uniq]
end
[type, visibilities]
end
[ MARSHAL_VERSION,
@name,
full_name,
@superclass,
parse(@comment),
attrs,
constants.map do |const|
[const.name, parse(const.comment)]
end,
includes.map do |incl|
[incl.name, parse(incl.comment)]
end,
method_types,
]
end
def marshal_load array # :nodoc:
initialize_methods_etc
@document_self = true
@done_documenting = false
@current_section = nil
@name = array[1]
@full_name = array[2]
@superclass = array[3]
@comment = array[4]
array[5].each do |name, rw|
add_attribute RDoc::Attr.new(nil, name, rw, nil)
end
array[6].each do |name, comment|
add_constant RDoc::Constant.new(name, nil, comment)
end
array[7].each do |name, comment|
add_include RDoc::Include.new(name, comment)
end
array[8].each do |type, visibilities|
visibilities.each do |visibility, methods|
@visibility = visibility
methods.each do |name|
method = RDoc::AnyMethod.new nil, name
method.singleton = true if type == 'class'
add_method method
end
end
end
end
##
# Merges +class_module+ into this ClassModule
def merge class_module
if class_module.comment then
document = parse @comment
class_module.comment.parts.push(*document.parts)
@comment = class_module.comment
end
class_module.each_attribute do |attr|
if match = attributes.find { |a| a.name == attr.name } then
match.rw = [match.rw, attr.rw].compact.join
else
add_attribute attr
end
end
class_module.each_constant do |const|
add_constant const
end
class_module.each_include do |incl|
add_include incl
end
class_module.each_method do |meth|
add_method meth
end
end
##
# Does this object represent a module?
def module?
false
end
##
# Path to this class or module
def path
http_url RDoc::RDoc.current.generator.class_dir
end
##
# Get the superclass of this class. Attempts to retrieve the superclass
# object, returns the name if it is not known.
def superclass
RDoc::TopLevel.find_class_named_from(@superclass, parent) || @superclass
end
##
# Set the superclass of this class to +superclass+
def superclass=(superclass)
raise NoMethodError, "#{full_name} is a module" if module?
@superclass = superclass if @superclass.nil? or @superclass == 'Object'
end
def to_s # :nodoc:
"#{self.class}: #{full_name} #{@comment} #{super}"
end
end
|