Class | ActiveLdap::Schema |
In: |
lib/active_ldap/schema/syntaxes.rb
lib/active_ldap/schema.rb |
Parent: | Object |
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('|')})/ |
# 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
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')
# 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 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