class ActiveLdap::Schema

Constants

DESCRIPTION_RE
NUMERIC_OID_RE
OID_RE
RESERVED_NAMES_RE

Public Class Methods

new(entries) click to toggle 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

[](group, id_or_name, attribute_name) click to toggle source
Alias for: fetch
attribute(name) click to toggle source
# File lib/active_ldap/schema.rb, line 90
def attribute(name)
  cache([:attribute, name]) do
    Attribute.new(name, self)
  end
end
attribute_type(name, attribute_name) click to toggle source
# File lib/active_ldap/schema.rb, line 104
def attribute_type(name, attribute_name)
  cache([:attribute_type, name, attribute_name]) do
    fetch("attributeTypes", name, attribute_name)
  end
end
attributes() click to toggle source
# File lib/active_ldap/schema.rb, line 96
def attributes
  cache([:attributes]) do
    names("attributeTypes").collect do |name|
      attribute(name)
    end
  end
end
dit_content_rule_attribute(name, attribute_name) click to toggle source
# File lib/active_ldap/schema.rb, line 130
def dit_content_rule_attribute(name, attribute_name)
  cache([:dit_content_rule_attribute, name, attribute_name]) do
    fetch("dITContentRules", name, attribute_name)
  end
end
dump(output=nil) click to toggle source
# File lib/active_ldap/schema.rb, line 156
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
entry(group, id_or_name) click to toggle 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 %r\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
exist_name?(group, name) click to toggle source
# File lib/active_ldap/schema.rb, line 23
def exist_name?(group, name)
  alias_map(group).has_key?(normalize_schema_name(name))
end
fetch(group, id_or_name, attribute_name) click to toggle source

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')
# 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
Also aliased as: []
ids(group) click to toggle 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
ldap_syntax(name) click to toggle source
# File lib/active_ldap/schema.rb, line 136
def ldap_syntax(name)
  cache([:ldap_syntax, name]) do
    Syntax.new(name, self)
  end
end
ldap_syntax_attribute(name, attribute_name) click to toggle source
# File lib/active_ldap/schema.rb, line 150
def ldap_syntax_attribute(name, attribute_name)
  cache([:ldap_syntax_attribute, name, attribute_name]) do
    fetch("ldapSyntaxes", name, attribute_name)
  end
end
ldap_syntaxes() click to toggle source
# File lib/active_ldap/schema.rb, line 142
def ldap_syntaxes
  cache([:ldap_syntaxes]) do
    ids("ldapSyntaxes").collect do |id|
      ldap_syntax(id)
    end
  end
end
names(group) click to toggle source
# File lib/active_ldap/schema.rb, line 19
def names(group)
  alias_map(group).keys
end
object_class(name) click to toggle source
# File lib/active_ldap/schema.rb, line 110
def object_class(name)
  cache([:object_class, name]) do
    ObjectClass.new(name, self)
  end
end
object_class_attribute(name, attribute_name) click to toggle source
# File lib/active_ldap/schema.rb, line 124
def object_class_attribute(name, attribute_name)
  cache([:object_class_attribute, name, attribute_name]) do
    fetch("objectClasses", name, attribute_name)
  end
end
object_classes() click to toggle source
# File lib/active_ldap/schema.rb, line 116
def object_classes
  cache([:object_classes]) do
    names("objectClasses").collect do |name|
      object_class(name)
    end
  end
end
resolve_name(group, name) click to toggle source
# File lib/active_ldap/schema.rb, line 27
def resolve_name(group, name)
  alias_map(group)[normalize_schema_name(name)]
end