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:



102
103
104
105
 
# File 'lib/net/ldap/dataset.rb', line 102

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

Instance Attribute Details

#comments ⇒ Object (readonly)

Dataset object comments.



29
30
31
 
# File 'lib/net/ldap/dataset.rb', line 29

def comments
  @comments
end

Class Method Details

.from_entry(entry) ⇒ Object

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



90
91
92
93
94
95
96
97
98
99
 
# File 'lib/net/ldap/dataset.rb', line 90

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.



45
46
47
48
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
 
# File 'lib/net/ldap/dataset.rb', line 45

def read_ldif(io) #:yields: entry-type, value Used mostly for debugging.
  ds = Net::LDAP::Dataset.new
  io = ChompedIO.new(io)

  line = io.gets
  dn = nil

  while line
    new_line = io.gets

    if new_line =~ /^[\s]+/
      line << " " << $'
    else
      nextline = new_line

      if line =~ /^#/
        ds.comments << line
        yield :comment, line if block_given?
      elsif line =~ /^dn:[\s]*/i
        dn = $'
        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.



143
144
145
146
147
148
149
150
151
152
153
 
# File 'lib/net/ldap/dataset.rb', line 143

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.



110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
 
# File 'lib/net/ldap/dataset.rb', line 110

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

    attributes = self[dn].keys.map { |attr| attr.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.



137
138
139
 
# File 'lib/net/ldap/dataset.rb', line 137

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