Class ActiveLdap::Schema
In: lib/active_ldap/schema/syntaxes.rb
lib/active_ldap/schema.rb
Parent: Object
Error AttributeAssignmentError AdapterNotSpecified OperationNotPermitted RequiredObjectClassMissed ConnectionError RequiredAttributeMissed LdifInvalid DistinguishedNameNotSetError EntryNotFound LdapError SaveError StrongAuthenticationRequired NotImplemented AdapterNotFound TimeoutError AuthenticationError AttributeValueInvalid EntryNotSaved DistinguishedNameInputInvalid EntryAlreadyExist ObjectClassError UnknownAttribute EntryInvalid DeleteError ConfigurationError ConnectionNotSetup DistinguishedNameInvalid Schema\n[lib/active_ldap/schema.rb\nlib/active_ldap/schema/syntaxes.rb] Base DistinguishedName Reloadable::Deprecated Reloadable::Subclasses Enumerable Ldif Collection EntryAttribute StandardError Children HasManyWrap HasMany BelongsToMany Proxy BelongsTo Normalizable Common Find LDIF Delete Update ActiveRecord::Callbacks GetText Parser Base\n[lib/active_ldap/adapter/base.rb\nlib/active_ldap/adapter/jndi.rb\nlib/active_ldap/adapter/ldap.rb\nlib/active_ldap/adapter/net_ldap.rb] Jndi Ldap NetLdap GetTextSupport ActiveRecord::Validations Xml JndiConnection lib/active_ldap/distinguished_name.rb lib/active_ldap/base.rb lib/active_ldap/xml.rb lib/active_ldap/schema.rb lib/active_ldap/entry_attribute.rb lib/active_ldap/ldif.rb lib/active_ldap/ldap_error.rb Compatible ClassMethods Associations LdapBenchmarking ActionController Populate lib/active_ldap/association/has_many_wrap.rb lib/active_ldap/association/children.rb lib/active_ldap/association/collection.rb lib/active_ldap/association/proxy.rb lib/active_ldap/association/belongs_to_many.rb lib/active_ldap/association/belongs_to.rb lib/active_ldap/association/has_many.rb HasManyUtils Association ClassMethods Tree Acts Command ClassMethods Normalizable Attributes Update Common ModifyNameRecordLoadable AddOperationModifiable DeleteOperationModifiable ReplaceOperationModifiable ModifyRecordLoadable DeleteRecordLoadable AddRecordLoadable ContentRecordLoadable LDIF Delete Find Operations GetTextSupport Escape ClassMethods Configuration ClassMethods ObjectClass ClassMethods Callbacks lib/active_ldap/get_text/parser.rb GetText lib/active_ldap/adapter/jndi_connection.rb lib/active_ldap/adapter/net_ldap.rb lib/active_ldap/adapter/ldap.rb lib/active_ldap/adapter/base.rb lib/active_ldap/adapter/jndi.rb Adapter Validations GetTextFallback Helper ClassMethods HumanReadable Salt UserPassword ClassMethods Connection ActiveLdap dot/m_46_0.png

Methods

Included Modules

GetTextSupport

Classes and Modules

Module ActiveLdap::Schema::Syntaxes
Class ActiveLdap::Schema::Attribute
Class ActiveLdap::Schema::Entry
Class ActiveLdap::Schema::ObjectClass
Class ActiveLdap::Schema::Syntax

Constants

NUMERIC_OID_RE = "\\d[\\d\\.]+"
DESCRIPTION_RE = "[a-zA-Z][a-zA-Z\\d\\-]*"
OID_RE = "(?:#{NUMERIC_OID_RE}|#{DESCRIPTION_RE}-oid)"
RESERVED_NAMES_RE = /(?:#{reserved_names.join('|')})/

Public Class methods

[Source]

    # 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

Public Instance methods

[](group, id_or_name, attribute_name)

Alias for fetch

[Source]

    # 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

[Source]

     # 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

[Source]

     # 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

[Source]

     # 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

[Source]

     # 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

[Source]

    # 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

[Source]

    # 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

fetch

This is just like LDAP::Schema#attribute except that it allows look up in any of the given keys. e.g.

 fetch('attributeTypes', 'cn', 'DESC')
 fetch('ldapSyntaxes', '1.3.6.1.4.1.1466.115.121.1.5', 'DESC')

[Source]

    # 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

[Source]

    # 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

[Source]

     # 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

[Source]

     # 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

[Source]

     # 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

[Source]

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

[Source]

     # 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

[Source]

     # 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

[Source]

     # 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

[Source]

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

Private Instance methods

[Source]

     # 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

[Source]

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

[Source]

     # 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

[Source]

     # 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

[Source]

     # 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

[Source]

     # 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

[Source]

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

[Source]

     # 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

[Source]

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

[Source]

     # 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

[Validate]