Class: ActiveLdap::Schema — activeldap - ActiveLdap

Class: ActiveLdap::Schema

Inherits:
Object
  • Object
show all
Includes:
GetTextSupport
Defined in:
lib/active_ldap/schema.rb,
lib/active_ldap/schema/syntaxes.rb

Defined Under Namespace

Modules: Syntaxes Classes: Attribute, Entry, ObjectClass, Syntax

Constant Summary

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

Instance Method Summary (collapse)

Constructor Details

- (Schema) initialize(entries)

Returns a new instance of Schema



5
6
7
8
9
10
# File 'lib/active_ldap/schema.rb', line 5

def initialize(entries)
  @entries = normalize_entries(entries || {})
  @schema_info = {}
  @class_attributes_info = {}
  @cache = {}
end

Instance Method Details

- (Object) attribute(name)



90
91
92
93
94
95
# 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

- (Object) attribute_type(name, attribute_name)



105
106
107
108
109
# 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

- (Object) attributes



97
98
99
100
101
102
103
# File 'lib/active_ldap/schema.rb', line 97

def attributes
  cache([:attributes]) do
    names("attributeTypes").collect do |name|
      attribute(name)
    end
  end
end

- (Object) dit_content_rule_attribute(name, attribute_name)



131
132
133
134
135
# 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

- (Object) dump(output = nil)



157
158
159
160
161
162
163
164
165
166
# 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

- (Object) entry(group, id_or_name)



49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
# 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

- (Boolean) exist_name?(group, name)

Returns:

  • (Boolean)


23
24
25
# File 'lib/active_ldap/schema.rb', line 23

def exist_name?(group, name)
  alias_map(group).has_key?(normalize_schema_name(name))
end

- (Object) fetch(group, id_or_name, attribute_name) Also known as: []

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')


38
39
40
41
42
43
# 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

- (Object) ids(group)



12
13
14
15
16
17
# 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

- (Object) ldap_syntax(name)



137
138
139
140
141
# File 'lib/active_ldap/schema.rb', line 137

def ldap_syntax(name)
  cache([:ldap_syntax, name]) do
    Syntax.new(name, self)
  end
end

- (Object) ldap_syntax_attribute(name, attribute_name)



151
152
153
154
155
# 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

- (Object) ldap_syntaxes



143
144
145
146
147
148
149
# 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

- (Object) names(group)



19
20
21
# File 'lib/active_ldap/schema.rb', line 19

def names(group)
  alias_map(group).keys
end

- (Object) object_class(name)



111
112
113
114
115
# File 'lib/active_ldap/schema.rb', line 111

def object_class(name)
  cache([:object_class, name]) do
    ObjectClass.new(name, self)
  end
end

- (Object) object_class_attribute(name, attribute_name)



125
126
127
128
129
# 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

- (Object) object_classes



117
118
119
120
121
122
123
# 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

- (Object) resolve_name(group, name)



27
28
29
# File 'lib/active_ldap/schema.rb', line 27

def resolve_name(group, name)
  alias_map(group)[normalize_schema_name(name)]
end