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

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

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

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

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

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

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

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

     # File lib/active_ldap/schema.rb, line 126
126:     def ldap_syntax(name)
127:       cache([:ldap_syntax, name]) do
128:         Syntax.new(name, self)
129:       end
130:     end

     # File lib/active_ldap/schema.rb, line 140
140:     def ldap_syntax_attribute(name, attribute_name)
141:       cache([:ldap_syntax_attribute, name, attribute_name]) do
142:         fetch("ldapSyntaxes", name, attribute_name)
143:       end
144:     end

     # File lib/active_ldap/schema.rb, line 132
132:     def ldap_syntaxes
133:       cache([:ldap_syntaxes]) do
134:         ids("ldapSyntaxes").collect do |id|
135:           ldap_syntax(id)
136:         end
137:       end
138:     end

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

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

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

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

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

     # File lib/active_ldap/schema.rb, line 219
219:     def alias_map(group)
220:       ensure_parse(group)
221:       return {} if @schema_info[group].nil?
222:       @schema_info[group][:aliases] || {}
223:     end

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

     # File lib/active_ldap/schema.rb, line 240
240:     def default_entries
241:       {
242:         "objectClasses" => [],
243:         "attributeTypes" => [],
244:         "ldapSyntaxes" => [],
245:       }
246:     end

     # File lib/active_ldap/schema.rb, line 157
157:     def determine_id_or_name(id_or_name, aliases)
158:       if /\A[\d\.]+\z/ =~ id_or_name
159:         id = id_or_name
160:         name = nil
161:       else
162:         name = normalize_schema_name(id_or_name)
163:         id = aliases[name]
164:       end
165:       [id, name]
166:     end

     # File lib/active_ldap/schema.rb, line 225
225:     def ensure_parse(group)
226:       return if @entries[group].nil?
227:       unless @entries[group].empty?
228:         fetch(group, 'nonexistent', 'nonexistent')
229:       end
230:     end

     # File lib/active_ldap/schema.rb, line 151
151:     def ensure_schema_info(group)
152:       @schema_info[group] ||= {:ids => {}, :aliases => {}}
153:       info = @schema_info[group]
154:       [info, info[:ids], info[:aliases]]
155:     end

     # File lib/active_ldap/schema.rb, line 236
236:     def normalize_attribute_name(name)
237:       name.upcase.gsub(/_/, "-")
238:     end

     # File lib/active_ldap/schema.rb, line 232
232:     def normalize_schema_name(name)
233:       name.downcase.sub(/;.*$/, '')
234:     end

     # File lib/active_ldap/schema.rb, line 190
190:     def parse_attributes(str, attributes)
191:       str.scan(/([A-Z\-_]+)\s+
192:                 (?:\(\s*([\w\-]+(?:\s+\$\s+[\w\-]+)+)\s*\)|
193:                    \(\s*([^\)]*)\s*\)|
194:                    '([^\']*)'|
195:                    ((?!#{RESERVED_NAMES_RE})[a-zA-Z][a-zA-Z\d\-;]*)|
196:                    (\d[\d\.\{\}]+)|
197:                    ()
198:                 )/x
199:                ) do |name, multi_amp, multi, string, literal, syntax, no_value|
200:         case
201:         when multi_amp
202:           values = multi_amp.rstrip.split(/\s*\$\s*/)
203:         when multi
204:           values = multi.scan(/\s*'([^\']*)'\s*/).collect {|value| value[0]}
205:         when string
206:           values = [string]
207:         when literal
208:           values = [literal]
209:         when syntax
210:           values = [syntax]
211:         when no_value
212:           values = ["TRUE"]
213:         end
214:         attributes[normalize_attribute_name(name)] ||= []
215:         attributes[normalize_attribute_name(name)].concat(values)
216:       end
217:     end