Class: Net::LDAP::Dataset

Inherits:
Hash
  • Object
show all
Defined in:
lib/net/ldap/dataset.rb

Overview

An LDAP Dataset. Used primarily as an intermediate format for converting to and from LDIF strings and Net::LDAP::Entry objects.

Defined Under Namespace

Classes: ChompedIO

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(*args, &block) ⇒ Dataset

:nodoc:



11
12
13
14
15
 
# File 'lib/net/ldap/dataset.rb', line 11

def initialize(*args, &block) # :nodoc:
  super
  @version  = nil
  @comments = []
end

Instance Attribute Details

#comments ⇒ Object (readonly)

Returns the value of attribute comments.



9
10
11
 
# File 'lib/net/ldap/dataset.rb', line 9

def comments
  @comments
end

#version ⇒ Object

Dataset object version, comments.



8
9
10
 
# File 'lib/net/ldap/dataset.rb', line 8

def version
  @version
end

Class Method Details

.from_entry(entry) ⇒ Object

Creates a Dataset object from an Entry object. Used mostly to assist with the conversion of



104
105
106
107
108
109
110
111
112
113
 
# File 'lib/net/ldap/dataset.rb', line 104

def from_entry(entry)
  dataset = Net::LDAP::Dataset.new
  hash = {}
  entry.each_attribute do |attribute, value|
    next if attribute == :dn
    hash[attribute] = value
  end
  dataset[entry.dn] = hash
  dataset
end

.read_ldif(io) ⇒ Object

Reads an object that returns data line-wise (using #gets) and parses LDIF data into a Dataset object.



118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
 
# File 'lib/net/ldap/dataset.rb', line 118

def read_ldif(io)
  ds = Net::LDAP::Dataset.new
  io = ChompedIO.new(io)

  line = io.gets
  dn = nil

  while line
    new_line = io.gets

    if new_line =~ /^ /
      line << $'
    else
      nextline = new_line

      if line =~ /^#/
        ds.comments << line
        yield :comment, line if block_given?
      elsif line =~ /^version:[\s]*([0-9]+)$/i
        ds.version = $1
        yield :version, line if block_given?
      elsif line =~ /^dn:([\:]?)[\s]*/i
        # $1 is a colon if the dn-value is base-64 encoded
        # $' is the dn-value
        # Avoid the Base64 class because not all Ruby versions have it.
        dn = ($1 == ":") ? $'.unpack('m').shift : $'
        ds[dn] = Hash.new { |k, v| k[v] = [] }
        yield :dn, dn if block_given?
      elsif line.empty?
        dn = nil
        yield :end, nil if block_given?
      elsif line =~ /^([^:]+):([\:]?)[\s]*/
        # $1 is the attribute name
        # $2 is a colon iff the attr-value is base-64 encoded
        # $' is the attr-value
        # Avoid the Base64 class because not all Ruby versions have it.
        attrvalue = ($2 == ":") ? $'.unpack('m').shift : $'
        ds[dn][$1.downcase.to_sym] << attrvalue
        yield :attr, [$1.downcase.to_sym, attrvalue] if block_given?
      end

      line = nextline
    end
  end

  ds
end

Instance Method Details

#to_entries ⇒ Object

Convert the parsed LDIF objects to Net::LDAP::Entry objects.



59
60
61
62
63
64
65
66
67
68
69
 
# File 'lib/net/ldap/dataset.rb', line 59

def to_entries
  ary = []
  keys.each do |dn|
    entry = Net::LDAP::Entry.new(dn)
    self[dn].each do |attr, value|
      entry[attr] = value
    end
    ary << entry
  end
  ary
end

#to_ldif ⇒ Object

Outputs an LDAP Dataset as an array of strings representing LDIF entries.



20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
# File 'lib/net/ldap/dataset.rb', line 20

def to_ldif
  ary = []

  if version
    ary << "version: #{version}"
    ary << ""
  end

  ary += @comments unless @comments.empty?
  keys.sort.each do |dn|
    ary << "dn: #{dn}"

    attributes = self[dn].keys.map(&:to_s).sort
    attributes.each do |attr|
      self[dn][attr.to_sym].each do |value|
        if attr == "userpassword" or value_is_binary?(value)
          value = [value].pack("m").chomp.gsub(/\n/m, "\n ")
          ary << "#{attr}:: #{value}"
        else
          ary << "#{attr}: #{value}"
        end
      end
    end

    ary << ""
  end
  block_given? and ary.each { |line| yield line}

  ary
end

#to_ldif_string ⇒ Object

Outputs an LDAP Dataset as an LDIF string.



53
54
55
 
# File 'lib/net/ldap/dataset.rb', line 53

def to_ldif_string
  to_ldif.join("\n")
end