# File lib/active_ldap/schema.rb, line 5
 5:     def initialize(entries)
 6:       @entries = normalize_entries(entries || {})
 7:       @schema_info = {}
 8:       @class_attributes_info = {}
 9:       @cache = {}
10:     end

    # File lib/active_ldap/schema.rb, line 88
88:     def attribute(name)
89:       cache([:attribute, name]) do
90:         Attribute.new(name, self)
91:       end
92:     end

     # File lib/active_ldap/schema.rb, line 102
102:     def attribute_type(name, attribute_name)
103:       cache([:attribute_type, name, attribute_name]) do
104:         fetch("attributeTypes", name, attribute_name)
105:       end
106:     end

     # File lib/active_ldap/schema.rb, line 94
 94:     def attributes
 95:       cache([:attributes]) do
 96:         names("attributeTypes").collect do |name|
 97:           attribute(name)
 98:         end
 99:       end
100:     end

     # File lib/active_ldap/schema.rb, line 128
128:     def dit_content_rule_attribute(name, attribute_name)
129:       cache([:dit_content_rule_attribute, name, attribute_name]) do
130:         fetch("dITContentRules", name, attribute_name)
131:       end
132:     end

     # File lib/active_ldap/schema.rb, line 154
154:     def dump(output=nil)
155:       require 'pp'
156:       output ||= STDOUT
157:       if output.respond_to?(:write)
158:         PP.pp(@entries, output)
159:       else
160:         open(output, "w") {|out| PP.pp(@entries, out)}
161:       end
162:       nil
163:     end

    # File lib/active_ldap/schema.rb, line 48
48:     def entry(group, id_or_name)
49:       return {} if group.empty? or id_or_name.empty?
50: 
51:       unless @entries.has_key?(group)
52:         raise ArgumentError, _("Unknown schema group: %s") % group
53:       end
54: 
55:       # Initialize anything that is required
56:       info, ids, aliases = ensure_schema_info(group)
57:       id, name = determine_id_or_name(id_or_name, aliases)
58: 
59:       # Check already parsed options first
60:       return ids[id] if ids.has_key?(id)
61: 
62:       schemata = @entries[group] || []
63:       while schema = schemata.shift
64:         next unless /\A\s*\(\s*(#{OID_RE})\s*(.*)\s*\)\s*\z/ =~ schema
65:         schema_id = $1
66:         rest = $2
67: 
68:         if ids.has_key?(schema_id)
69:           attributes = ids[schema_id]
70:         else
71:           attributes = {}
72:           ids[schema_id] = attributes
73:         end
74: 
75:         parse_attributes(rest, attributes)
76:         (attributes["NAME"] || []).each do |v|
77:           normalized_name = normalize_schema_name(v)
78:           aliases[normalized_name] = schema_id
79:           id = schema_id if id.nil? and name == normalized_name
80:         end
81: 
82:         break if id == schema_id
83:       end
84: 
85:       ids[id || aliases[name]] || {}
86:     end

    # File lib/active_ldap/schema.rb, line 22
22:     def exist_name?(group, name)
23:       alias_map(group).has_key?(normalize_schema_name(name))
24:     end

    # File lib/active_ldap/schema.rb, line 37
37:     def fetch(group, id_or_name, attribute_name)
38:       return [] if attribute_name.empty?
39:       attribute_name = normalize_attribute_name(attribute_name)
40:       value = entry(group, id_or_name)[attribute_name]
41:       value ? value.dup : []
42:     end

    # File lib/active_ldap/schema.rb, line 12
12:     def ids(group)
13:       ensure_parse(group)
14:       info, ids, aliases = ensure_schema_info(group)
15:       ids.keys
16:     end

     # File lib/active_ldap/schema.rb, line 134
134:     def ldap_syntax(name)
135:       cache([:ldap_syntax, name]) do
136:         Syntax.new(name, self)
137:       end
138:     end

     # File lib/active_ldap/schema.rb, line 148
148:     def ldap_syntax_attribute(name, attribute_name)
149:       cache([:ldap_syntax_attribute, name, attribute_name]) do
150:         fetch("ldapSyntaxes", name, attribute_name)
151:       end
152:     end

     # File lib/active_ldap/schema.rb, line 140
140:     def ldap_syntaxes
141:       cache([:ldap_syntaxes]) do
142:         ids("ldapSyntaxes").collect do |id|
143:           ldap_syntax(id)
144:         end
145:       end
146:     end

    # File lib/active_ldap/schema.rb, line 18
18:     def names(group)
19:       alias_map(group).keys
20:     end

     # File lib/active_ldap/schema.rb, line 108
108:     def object_class(name)
109:       cache([:object_class, name]) do
110:         ObjectClass.new(name, self)
111:       end
112:     end

     # File lib/active_ldap/schema.rb, line 122
122:     def object_class_attribute(name, attribute_name)
123:       cache([:object_class_attribute, name, attribute_name]) do
124:         fetch("objectClasses", name, attribute_name)
125:       end
126:     end

     # File lib/active_ldap/schema.rb, line 114
114:     def object_classes
115:       cache([:object_classes]) do
116:         names("objectClasses").collect do |name|
117:           object_class(name)
118:         end
119:       end
120:     end

    # File lib/active_ldap/schema.rb, line 26
26:     def resolve_name(group, name)
27:       alias_map(group)[normalize_schema_name(name)]
28:     end

     # File lib/active_ldap/schema.rb, line 238
238:     def alias_map(group)
239:       ensure_parse(group)
240:       return {} if @schema_info[group].nil?
241:       @schema_info[group][:aliases] || {}
242:     end

     # File lib/active_ldap/schema.rb, line 166
166:     def cache(key)
167:       (@cache[key] ||= [yield])[0]
168:     end

     # File lib/active_ldap/schema.rb, line 259
259:     def default_entries
260:       {
261:         "objectClasses" => [],
262:         "attributeTypes" => [],
263:         "ldapSyntaxes" => [],
264:         "dITContentRules" => [],
265:         "matchingRules" => [],
266:       }
267:     end

     # File lib/active_ldap/schema.rb, line 176
176:     def determine_id_or_name(id_or_name, aliases)
177:       if /\A[\d\.]+\z/ =~ id_or_name
178:         id = id_or_name
179:         name = nil
180:       else
181:         name = normalize_schema_name(id_or_name)
182:         id = aliases[name]
183:       end
184:       [id, name]
185:     end

     # File lib/active_ldap/schema.rb, line 244
244:     def ensure_parse(group)
245:       return if @entries[group].nil?
246:       unless @entries[group].empty?
247:         fetch(group, 'nonexistent', 'nonexistent')
248:       end
249:     end

     # File lib/active_ldap/schema.rb, line 170
170:     def ensure_schema_info(group)
171:       @schema_info[group] ||= {:ids => {}, :aliases => {}}
172:       info = @schema_info[group]
173:       [info, info[:ids], info[:aliases]]
174:     end

     # File lib/active_ldap/schema.rb, line 255
255:     def normalize_attribute_name(name)
256:       name.upcase.gsub(/_/, "-")
257:     end

     # File lib/active_ldap/schema.rb, line 269
269:     def normalize_entries(entries)
270:       normalized_entries = default_entries
271:       normalized_keys = normalized_entries.keys
272:       entries.each do |name, values|
273:         normalized_name = normalized_keys.find do |key|
274:           key.downcase == name
275:         end
276:         normalized_entries[normalized_name || name] = values
277:       end
278:       normalized_entries
279:     end

     # File lib/active_ldap/schema.rb, line 251
251:     def normalize_schema_name(name)
252:       name.downcase.sub(/;.*$/, '')
253:     end

     # File lib/active_ldap/schema.rb, line 209
209:     def parse_attributes(str, attributes)
210:       str.scan(/([A-Z\-_]+)\s+
211:                 (?:\(\s*(\w[\w\-;]*(?:\s+\$\s+\w[\w\-;]*)*)\s*\)|
212:                    \(\s*([^\)]*)\s*\)|
213:                    '([^\']*)'|
214:                    ((?!#{RESERVED_NAMES_RE})[a-zA-Z][a-zA-Z\d\-;]*)|
215:                    (\d[\d\.\{\}]+)|
216:                    ()
217:                 )/x
218:                ) do |name, multi_amp, multi, string, literal, syntax, no_value|
219:         case
220:         when multi_amp
221:           values = multi_amp.rstrip.split(/\s*\$\s*/)
222:         when multi
223:           values = multi.scan(/\s*'([^\']*)'\s*/).collect {|value| value[0]}
224:         when string
225:           values = [string]
226:         when literal
227:           values = [literal]
228:         when syntax
229:           values = [syntax]
230:         when no_value
231:           values = ["TRUE"]
232:         end
233:         attributes[normalize_attribute_name(name)] ||= []
234:         attributes[normalize_attribute_name(name)].concat(values)
235:       end
236:     end