| Class | RDoc::RI::ClassEntry |
| In: |
ri/cache.rb
|
| Parent: | Object |
# File ri/cache.rb, line 8
8: def initialize(path_name, name, in_class)
9: @path_names = [ path_name ]
10: @name = name
11: @in_class = in_class
12: @class_methods = []
13: @instance_methods = []
14: @inferior_classes = []
15: end
We found this class in more tha one place, so add in the name from there.
# File ri/cache.rb, line 19
19: def add_path(path)
20: @path_names << path
21: end
Return a list of all out method names
# File ri/cache.rb, line 102
102: def all_method_names
103: res = @class_methods.map {|m| m.full_name }
104: @instance_methods.each {|m| res << m.full_name}
105: res
106: end
Return an exact match to a particular name
# File ri/cache.rb, line 72
72: def contained_class_named(name)
73: @inferior_classes.find {|c| c.name == name}
74: end
Return a list of any classes or modules that we contain that match a given string
# File ri/cache.rb, line 63
63: def contained_modules_matching(name)
64: @inferior_classes.find_all {|c| c.name[name]}
65: end
Return our full name
# File ri/cache.rb, line 95
95: def full_name
96: res = @in_class.full_name
97: res << "::" unless res.empty?
98: res << @name
99: end
read in our methods and any classes and modules in our namespace. Methods are stored in files called name-c|i.yaml, where the ‘name’ portion is the external form of the method name and the c|i is a class|instance flag
# File ri/cache.rb, line 30
30: def load_from(dir)
31: Dir.foreach(dir) do |name|
32: next if name =~ /^\./
33:
34: # convert from external to internal form, and
35: # extract the instance/class flag
36:
37: if name =~ /^(.*?)-(c|i).yaml$/
38: external_name = $1
39: is_class_method = $2 == "c"
40: internal_name = RiWriter.external_to_internal(external_name)
41: list = is_class_method ? @class_methods : @instance_methods
42: path = File.join(dir, name)
43: list << MethodEntry.new(path, internal_name, is_class_method, self)
44: else
45: full_name = File.join(dir, name)
46: if File.directory?(full_name)
47: inf_class = @inferior_classes.find {|c| c.name == name }
48: if inf_class
49: inf_class.add_path(full_name)
50: else
51: inf_class = ClassEntry.new(full_name, name, self)
52: @inferior_classes << inf_class
53: end
54: inf_class.load_from(full_name)
55: end
56: end
57: end
58: end
Return a list of all our methods matching a given string. Is is_class_methods if ‘nil’, we don‘t care if the method is a class method or not, otherwise we only return those methods that match
# File ri/cache.rb, line 114
114: def local_methods_matching(name, is_class_method)
115:
116: list = case is_class_method
117: when nil then @class_methods + @instance_methods
118: when true then @class_methods
119: when false then @instance_methods
120: else fail "Unknown is_class_method: #{is_class_method.inspect}"
121: end
122:
123: list.find_all {|m| m.name; m.name[name]}
124: end
return the list of local methods matching name We‘re split into two because we need distinct behavior when called from the toplevel
# File ri/cache.rb, line 79
79: def methods_matching(name, is_class_method)
80: local_methods_matching(name, is_class_method)
81: end
Find methods matching ‘name’ in ourselves and in any classes we contain
# File ri/cache.rb, line 85
85: def recursively_find_methods_matching(name, is_class_method)
86: res = local_methods_matching(name, is_class_method)
87: @inferior_classes.each do |c|
88: res.concat(c.recursively_find_methods_matching(name, is_class_method))
89: end
90: res
91: end