class ActiveLdap::Schema
Constants
- DESCRIPTION_RE
- NUMERIC_OID_RE
- OID_RE
- RESERVED_NAMES_RE
Public Class Methods
Source
# File lib/active_ldap/schema.rb, line 5 def initialize(entries) @entries = normalize_entries(entries || {}) @schema_info = {} @class_attributes_info = {} @cache = {} end
Public Instance Methods
Source
# File lib/active_ldap/schema.rb, line 90 def attribute(name) name = name.to_s if name.is_a?(Symbol) cache([:attribute, name]) do Attribute.new(name, self) end end
Source
# File lib/active_ldap/schema.rb, line 105 def attribute_type(name, attribute_name) cache([:attribute_type, name, attribute_name]) do fetch("attributeTypes", name, attribute_name) end end
Source
# File lib/active_ldap/schema.rb, line 97 def attributes cache([:attributes]) do names("attributeTypes").collect do |name| attribute(name) end end end
Source
# File lib/active_ldap/schema.rb, line 131 def dit_content_rule_attribute(name, attribute_name) cache([:dit_content_rule_attribute, name, attribute_name]) do fetch("dITContentRules", name, attribute_name) end end
Source
# File lib/active_ldap/schema.rb, line 157 def dump(output=nil) require 'pp' output ||= STDOUT if output.respond_to?(:write) PP.pp(@entries, output) else open(output, "w") {|out| PP.pp(@entries, out)} end nil end
Source
# File lib/active_ldap/schema.rb, line 49 def entry(group, id_or_name) return {} if group.empty? or id_or_name.empty? unless @entries.has_key?(group) raise ArgumentError, _("Unknown schema group: %s") % group end # Initialize anything that is required info, ids, aliases = ensure_schema_info(group) _ = info # for suppress a warning on Ruby 1.9.3 id, name = determine_id_or_name(id_or_name, aliases) # Check already parsed options first return ids[id] if ids.has_key?(id) schemata = @entries[group] || [] while schema = schemata.shift next unless /\A\s*\(\s*(#{OID_RE})\s*(.*)\s*\)\s*\z/ =~ schema schema_id = $1 rest = $2 if ids.has_key?(schema_id) attributes = ids[schema_id] else attributes = {} ids[schema_id] = attributes end parse_attributes(rest, attributes) (attributes["NAME"] || []).each do |v| normalized_name = normalize_schema_name(v) aliases[normalized_name] = schema_id id = schema_id if id.nil? and name == normalized_name end break if id == schema_id end ids[id || aliases[name]] || {} end
Source
# File lib/active_ldap/schema.rb, line 23 def exist_name?(group, name) alias_map(group).has_key?(normalize_schema_name(name)) end
Source
# File lib/active_ldap/schema.rb, line 38 def fetch(group, id_or_name, attribute_name) return [] if attribute_name.empty? attribute_name = normalize_attribute_name(attribute_name) value = entry(group, id_or_name)[attribute_name] value ? value.dup : [] 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')
Also aliased as: []
Source
# File lib/active_ldap/schema.rb, line 12 def ids(group) ensure_parse(group) info, ids, aliases = ensure_schema_info(group) _ = info = aliases # for suppress a warning on Ruby 1.9.3 ids.keys end
Source
# File lib/active_ldap/schema.rb, line 137 def ldap_syntax(name) cache([:ldap_syntax, name]) do Syntax.new(name, self) end end
Source
# File lib/active_ldap/schema.rb, line 151 def ldap_syntax_attribute(name, attribute_name) cache([:ldap_syntax_attribute, name, attribute_name]) do fetch("ldapSyntaxes", name, attribute_name) end end
Source
# File lib/active_ldap/schema.rb, line 143 def ldap_syntaxes cache([:ldap_syntaxes]) do ids("ldapSyntaxes").collect do |id| ldap_syntax(id) end end end
Source
# File lib/active_ldap/schema.rb, line 19 def names(group) alias_map(group).keys end
Source
# File lib/active_ldap/schema.rb, line 111 def object_class(name) cache([:object_class, name]) do ObjectClass.new(name, self) end end
Source
# File lib/active_ldap/schema.rb, line 125 def object_class_attribute(name, attribute_name) cache([:object_class_attribute, name, attribute_name]) do fetch("objectClasses", name, attribute_name) end end
Source
# File lib/active_ldap/schema.rb, line 117 def object_classes cache([:object_classes]) do names("objectClasses").collect do |name| object_class(name) end end end
Source
# File lib/active_ldap/schema.rb, line 27 def resolve_name(group, name) alias_map(group)[normalize_schema_name(name)] end
Private Instance Methods
Source
# File lib/active_ldap/schema.rb, line 241 def alias_map(group) ensure_parse(group) return {} if @schema_info[group].nil? @schema_info[group][:aliases] || {} end
Source
# File lib/active_ldap/schema.rb, line 169 def cache(key) (@cache[key] ||= [yield])[0] end
Source
# File lib/active_ldap/schema.rb, line 262 def default_entries { "objectClasses" => [], "attributeTypes" => [], "ldapSyntaxes" => [], "dITContentRules" => [], "matchingRules" => [], } end
Source
# File lib/active_ldap/schema.rb, line 179 def determine_id_or_name(id_or_name, aliases) if /\A[\d\.]+\z/ =~ id_or_name id = id_or_name name = nil else name = normalize_schema_name(id_or_name) id = aliases[name] end [id, name] end
Source
# File lib/active_ldap/schema.rb, line 247 def ensure_parse(group) return if @entries[group].nil? unless @entries[group].empty? fetch(group, 'nonexistent', 'nonexistent') end end
Source
# File lib/active_ldap/schema.rb, line 173 def ensure_schema_info(group) @schema_info[group] ||= {:ids => {}, :aliases => {}} info = @schema_info[group] [info, info[:ids], info[:aliases]] end
Source
# File lib/active_ldap/schema.rb, line 258 def normalize_attribute_name(name) name.upcase.gsub(/_/, "-") end
Source
# File lib/active_ldap/schema.rb, line 272 def normalize_entries(entries) normalized_entries = default_entries normalized_keys = normalized_entries.keys entries.each do |name, values| normalized_name = normalized_keys.find do |key| key.downcase == name end normalized_entries[normalized_name || name] = values end normalized_entries end
Source
# File lib/active_ldap/schema.rb, line 254 def normalize_schema_name(name) name.downcase.sub(/;.*$/, '') end
Source
# File lib/active_ldap/schema.rb, line 212 def parse_attributes(str, attributes) str.scan(/([A-Z\-_]+)\s+ (?:\(\s*(\w[\w\-;]*(?:\s+\$\s+\w[\w\-;]*)*)\s*\)| \(\s*([^\)]*)\s*\)| '([^\']*)'| ((?!#{RESERVED_NAMES_RE})[a-zA-Z][a-zA-Z\d\-;]*)| (\d[\d\.\{\}]+)| () )/x ) do |name, multi_amp, multi, string, literal, syntax, no_value| case when multi_amp values = multi_amp.rstrip.split(/\s*\$\s*/) when multi values = multi.scan(/\s*'([^\']*)'\s*/).collect {|value| value[0]} when string values = [string] when literal values = [literal] when syntax values = [syntax] when no_value values = ["TRUE"] end attributes[normalize_attribute_name(name)] ||= [] attributes[normalize_attribute_name(name)].concat(values) end end